मैं एक ही GPU के साथ एक ही मुद्दे में चल रहा हूं: "CUDNN_STATUS_INTERNAL_ERROR"।

RTX 2070 जीपीयू
CUDA 10
cuDNN 7.4.2
उबुन्टु 18.04
tf-nightly-gpu (r1.13, 13 जनवरी)
अजगर 3.6.7

2019-01-15 05:01:03.503415: I tensorflow/stream_executor/platform/default/dso_loader.cc:154] successfully opened CUDA li
brary libcublas.so.10.0 locally
2019-01-15 05:01:03.752563: I tensorflow/stream_executor/platform/default/dso_loader.cc:154] successfully opened CUDA li
brary libcudnn.so.7 locally
2019-01-15 05:01:04.905618: E tensorflow/stream_executor/cuda/cuda_dnn.cc:493] Could not create cudnn handle: CUDNN_STAT
US_INTERNAL_ERROR
2019-01-15 05:01:04.908147: E tensorflow/stream_executor/cuda/cuda_dnn.cc:493] Could not create cudnn handle: CUDNN_STAT
US_INTERNAL_ERROR
2019-01-15 05:01:04.908191: W tensorflow/core/framework/op_kernel.cc:1412] OP_REQUIRES failed at conv_ops_fused.cc:801 :
 Unknown: Failed to get convolution algorithm. This is probably because cuDNN failed to initialize, so try looking to se
e if a warning log message was printed above.

मैं एक ही समस्या चल रहा है

RTX2080 GPU
CUDA 10
cudnn 7.4.2

मैंने निम्नलिखित tf संस्करणों की कोशिश की tf-nightly-gpu और एक स्व संकलित संस्करण गुरु से (060b6e32ad)।
मुझे पता चला कि इसके आगे डीबग जानकारी प्राप्त करने के लिए निम्नलिखित पर्यावरण चर सेट करने के लिए संभव है।

CUDNN_LOGINFO_DBG = 1;
CUDNN_LOGDEST_DBG = stdout

तब मुझे निम्न त्रुटि मिलती है:

I0117 14: 11: 24.441819 140433563125568 basic_session_run_hooks.py/94] 0t //mp/mnist/model.ckpt में 0 के लिए चौकियों को सहेजना।
2019-01-17 14: 11: 25.916269: I टेंसोफ़्लो / स्ट्रीम_एक्सप्लिकॉर / प्लेटफ़ॉर्म / डिफ़ॉल्ट / dso_loader.cc: 154] स्थानीय स्तर पर सफलतापूर्वक CUDA लाइब्रेरी libcublas.so.10.0 खोला गया

मैं! CuDNN (v7402) फ़ंक्शन cudnnCreate () कहा जाता है:
मैं! समय: 2019-01-17T14: 11: 26.079184 (0d + 0h + 0m + 0s प्रारंभ से)
मैं! प्रक्रिया = 29255; धागा = 29356; GPU = NULL; संभाल = पूरा; स्ट्रीमआईड = NULL।

2019-01-17 14: 11: 26.079151: मैं टेंसोफ़्लो / स्ट्रीम_एक्सॉज़िटर / प्लेटफ़ॉर्म / डिफ़ॉल्ट / dso_loader.cc: 154] स्थानीय स्तर पर सफलतापूर्वक CUDA लाइब्रेरी libcudnn.so.7 खोला गया

मैं! CuDNN (v7402) फ़ंक्शन cudnnCreate () कहा जाता है:
मैं! समय: 2019-01-17T14: 11: 26.571897 (0d + 0h + 0m + 0s प्रारंभ से)
मैं! प्रक्रिया = 29255; धागा = 29356; GPU = NULL; संभाल = पूरा; स्ट्रीमआईड = NULL।

2019-01-17 14: 11: 26.571858: ई टेंसोफ़्लो / स्ट्रीम_एक्सलेटर / कूडा / cuda_dnn.cc: 493] cudnn हैंडल नहीं बना सका: CUDNN_STATIN_INTERNAL_ERROR
2019-01-17 14: 11: 26.579375: ई टेंसोफ़्लो / स्ट्रीम_एक्सलेटर / कूडा / cuda_dnn.cc: 493] cudnn हैंडल नहीं बना सका: CUDNN_STATIN_INTERNAL_ERROR

मैं! CuDNN (v7402) फ़ंक्शन cudnnCreate () कहा जाता है:
मैं! समय: 2019-01-17T14: 11: 26.579803 (0d + 0h + 0m + 0s प्रारंभ से)
मैं! प्रक्रिया = 29255; धागा = 29356; GPU = NULL; संभाल = पूरा; स्ट्रीमआईड = NULL।

2019-01-17 14: 11: 26.585818: ई टेंसोफ़्लो / स्ट्रीम_एक्सलेटर / कूडा / cuda_dnn.cc: 493] cudnn हैंडल नहीं बना सका: CUDNN_STATIN_INTERNAL_ERROR
2019-01-17 14: 11: 26.585850: W ./tensorflow/stream_executor/stream.h:2109] DNN समर्थन के बिना StreamExecutor का उपयोग करके DNN ऑपरेशन करने का प्रयास
ट्रेसबैक (सबसे हालिया कॉल अंतिम):
फ़ाइल "/usr/local/lib/python3.6/dist-packages/tensorflow/python/client/session.py", पंक्ति 1335, _do_call में
वापसी fn (* args)
फ़ाइल "/usr/local/lib/python3.6/dist-packages/tensorflow/python/client/session.py", पंक्ति 1320, _run_fn में
विकल्प, feed_dict, fetch_list, target_list, run_metadata)
फ़ाइल "/usr/local/lib/python3.6/dist-packages/tensorflow/python/client/session.py", पंक्ति 1408, _call_tf_sessionrun में
run_metadata)
टेंसोरफ़्लोफ़्थोन.फ़्रामवर्क.errors_impl.UnognError: कनविक्शन एल्गोरिथ्म प्राप्त करने में विफल। यह संभवतः इसलिए है क्योंकि cuDNN आरंभ करने में विफल रहा, इसलिए यह देखने की कोशिश करें कि क्या चेतावनी लॉग संदेश ऊपर मुद्रित किया गया था।
[[{{नोड डिस्क्रिमिनेटर १ / कन्वोकेशन / कन्वर्शन २}}]]
[[ट्रेन / विभेदक_ट्रेन / ट्रेन_प / नियंत्रण_ निर्भरता / _ ५६ ९]]

उपरोक्त अपवाद से निपटने के दौरान, एक और अपवाद हुआ:

ट्रेसबैक (सबसे हालिया कॉल अंतिम):
फ़ाइल "/home/dj/projects/gan/tf_models/research/gan/mnist/train.py", पंक्ति 151, में
tf.app.run ()
फ़ाइल "/usr/local/lib/python3.6/dist-packages/tensorflow/python/platform/app.py", पंक्ति 125, रन में
_sys.exit (मुख्य (argv))
फ़ाइल "/home/dj/projects/gan/tf_models/research/gan/mnist/train.py", पंक्ति 147, मुख्य रूप से
get_hooks_fn = tfgan.get_joint_train_hooks ())
फ़ाइल "/usr/local/lib/python3.6/dist-packages/tensorflow/contrib/gan/python/train.py", पंक्ति 1200, gan_train में
config = config)
फ़ाइल "/usr/local/lib/python3.6/dist-packages/tensorflow/contrib/training/python/training/training.py", पंक्ति 546, ट्रेन में
loss = session.run (train_op, run_metadata = run_metadata)
फ़ाइल "/usr/local/lib/python3.6/dist-packages/tensorflow/python/training/monitored_session.py", लाइन 693, रन में
run_metadata = run_metadata)
फ़ाइल "/usr/local/lib/python3.6/dist-packages/tensorflow/python/training/monitored_session.py", पंक्ति 1188, रन में
run_metadata = run_metadata)
फ़ाइल "/usr/local/lib/python3.6/dist-packages/tensorflow/python/training/monitored_session.py", पंक्ति 1287, रन में
छह उठाएँ। मूल (मूल_एक्ससी_इन्फो




फ़ाइल "/usr/local/lib/python3.6/dist-packages/tensorflow/python/training/monitored_session.py", पंक्ति 1336, रन में
feed_dict, विकल्प)
फ़ाइल "/usr/local/lib/python3.6/dist-packages/tensorflow/python/training/monitored_session.py", पंक्ति 1362, _call_book_before_run में
अनुरोध = hook.before_run (run_context)
फ़ाइल "/usr/local/lib/python3.6/dist-packages/tensorflow/contrib/gan/python/train.py", पंक्ति 1061, इससे पहले_रुन में
run_context.session.run (self._train_ops)
फ़ाइल "/usr/local/lib/python3.6/dist-packages/tensorflow/python/client/session.py", पंक्ति 930, रन में
run_metadata_ptr)
फाइल "/usr/local/lib/python3.6/dist-packages/tensorflow/python/client/session.py", पंक्ति 1153, _run में
feed_dict_tensor, विकल्प, run_metadata)
फ़ाइल "/usr/local/lib/python3.6/dist-packages/tensorflow/python/client/session.py", पंक्ति 1329, _do_run में
run_metadata)
फ़ाइल "/usr/local/lib/python3.6/dist-packages/tensorflow/python/client/session.py", पंक्ति 1349, _do_call में
उठाना प्रकार (ई) (नोड_डेफ़, ऑप, संदेश)
टेंसोरफ़्लोफ़्थोन.फ़्रामवर्क.errors_impl.UnognError: कनविक्शन एल्गोरिथ्म प्राप्त करने में विफल। यह संभवतः इसलिए है क्योंकि cuDNN आरंभ करने में विफल रहा, इसलिए यह देखने की कोशिश करें कि क्या चेतावनी लॉग संदेश ऊपर मुद्रित किया गया था।
[[नोड Discriminator_1 / Conv / Conv2D (घर / डीजे / परियोजनाओं / गण / tf_models / अनुसंधान / गण / mnist / networks.py पर परिभाषित: 152)]]
[[ट्रेन / विभेदक_ट्रेन / ट्रेन_प / नियंत्रण_ निर्भरता / _ ५६ ९]]

त्रुटियां एक इनपुट ऑपरेशन से उत्पन्न हुई हो सकती हैं।
नोड डिस्क्रिमिनेटर से जुड़े इनपुट सोर्स ऑपरेशन
आदानों / बैच / एन (घर / डीजे / परियोजनाओं / गण / tf_models / अनुसंधान / गण / mnist / data_provider.py: 67 पर परिभाषित)

'Discriminator_1 / Conv / Conv2D' के लिए मूल स्टैक ट्रेस:
फ़ाइल "घर / डीजे / परियोजनाओं / गण / tf_models / अनुसंधान / गण / mnist / train.py", लाइन 151, में
tf.app.run ()
फ़ाइल "usr / local / lib / python3.6 / dist-package / tanorflow / python / platform / app.py", line 125, in run
_sys.exit (मुख्य (argv))
फ़ाइल "घर / डीजे / परियोजनाओं / गण / tf_models / अनुसंधान / गण / mnist / train.py", लाइन 87, मुख्य में
[FLAGS.batch_size, FLAGS.noise_dims]))
फ़ाइल "usr / local / lib / python3.6 / dist-package / tanorflow / contrib / gan / python / train.py", line 118, gan_model में
discriminator_real_outputs = discriminator_fn (real_data, जनरेटर_inputs)
फ़ाइल "घर / डीजे / परियोजनाओं / गण / tf_models / अनुसंधान / गण / mnist / networks.py", रेखा 176, बिना शर्त_विषयक में
net = _discriminator_helper (img, गलत, कोई नहीं, weight_decay)
फ़ाइल "घर / डीजे / प्रोजेक्ट्स / गण / tf_models / अनुसंधान / गण / mnist / networks.py", पंक्ति 152, _discriminator_helper में
शुद्ध = परतें .conv2d (img, 64, [4, 4], स्ट्राइड = 2)
फ़ाइल "usr / local / lib / python3.6 / dist-package / tanorflow / contrib / ढांचा / python / ops / arg_scope.py", पंक्ति 182, func_with_bgs में
वापसी func ( args, * current_args)
फ़ाइल "usr / local / lib / python3.6 / dist-package / tanorflow / contrib / परतों / python / परतों / परतों", पंक्ति 1155, convolution2d में
conv_dims = 2)
फ़ाइल "usr / local / lib / python3.6 / dist-package / tanorflow / contrib / ढांचा / python / ops / arg_scope.py", पंक्ति 182, func_with_bgs में
वापसी func ( args, * current_args)
फ़ाइल "usr / स्थानीय / lib / python3.6 / dist-package / tanorflow / contrib / परतों / python / परतों / परतों", पंक्ति 1058, में दृढ़ संकल्प
आउटपुट = लेयर ।apply (इनपुट्स)
फाइल "usr / local / lib / python3.6 / dist-package / tensorflow / python / keras / engine / base_layer.py", पंक्ति 1228, आवेदन में
स्व वापस लौटें .__ कॉल __ (इनपुट्स, आर्ग्स, * क्वार्ग्स)
फ़ाइल "usr / local / lib / python3.6 / dist-package / tanorflow / python / परतों / base.py", पंक्ति 531, __call__ में
आउटपुट = सुपर (परत, स्व) .__ कॉल __ (इनपुट्स, आर्ग्स, * क्वार्ग्स)
फ़ाइल "usr / local / lib / python3.6 / dist-package / tensorflow / python / keras / engine / base_layer.py", पंक्ति 564, __call__ में
आउटपुट = self.call (इनपुट्स, आर्ग्स , * क्वार्ग्स)
फ़ाइल "usr / स्थानीय / lib / python3.6 / dist-package / tanorflow / python / keras / परतों / convolutional.py", पंक्ति 196, कॉल में
आउटपुट = self._convolution_op (इनपुट, स्व। कर्नेल)
फ़ाइल "usr / local / lib / python3.6 / dist-package / tensorflow / python / ops / nn_ops.py", पंक्ति 966, __call__ में
स्व वापस करें ।conv_op (inp, फ़िल्टर)
फ़ाइल "usr / local / lib / python3.6 / dist-package / tensorflow / python / ops / nn_ops.py", लाइन 591, __call__ में
स्व.पॉल लौटें। (inp, फ़िल्टर)
फ़ाइल "usr / local / lib / python3.6 / dist-package / tensorflow / python / ops / nn_ops.py", पंक्ति 208, __call__ में
नाम = self.name)
फ़ाइल "usr / local / lib / python3.6 / dist-package / tanorflow / python / ops / nn_ops.py", पंक्ति 1578, conv2d में
नाम = नाम)
फ़ाइल "usr / local / lib / python3.6 / dist-package / tanorflow / python / ops / gen_nn_ops.py", पंक्ति 1040, conv2d में
data_format = data_format, dilations = dilations, name = name)
फ़ाइल "usr / local / lib / python3.6 / dist-package / tensorflow / python / फ्रेमवर्क / op_def_library.py", पंक्ति 788, _apply_op_helper में
op_def = op_def)
फ़ाइल "usr / local / lib / python3.6 / dist-package / tensorflow / python / उपयोग / deprecation.py", लाइन 501, new_func में
वापसी func ( args, * kwargs)
फ़ाइल "usr / स्थानीय / lib / python3.6 / dist-package / tanorflow / python / फ्रेमवर्क / ops.py", लाइन 3300, create_op में
op_def = op_def)
फ़ाइल "usr / स्थानीय / lib / python3.6 / dist-package / tanorflow / python / ढांचा / ops.py", पंक्ति 1801, __in__ में
self._traceback = tf_stack.extract_stack ()

किसी को कोई विचार? मैं अपना पूरा वातावरण पुनः स्थापित करने से पहले हूं :-(

स्रोत से r1.13 संकलन करने का प्रयास करें। इसमें लंबा समय लगेगा, लेकिन यह आपकी समस्या को ठीक कर सकता है। कम से कम यह मेरा तय किया।

मैंने स्रोत से संकलन करने का प्रयास किया, लेकिन उसी मुद्दे में भाग गया। मैं अंत में अपनी समस्या को ठीक करने में सक्षम था config.gpu_options.allow_growth = True सेट कर रहा था।

मैं एक ही मुद्दा रहा है (RTX 2060 पर, Ubuntu 18.04, Python 3.6.7, CUDA 10.0.130, cuDNN 7.4.2, Tensorflow 1.13.0-rc0 स्रोत से)। @ Va-andrew के सुझाव के लिए धन्यवाद, मेरे पास यह allow_growth विकल्प के साथ काम कर रहा है।

एफडब्ल्यूआईडब्ल्यू, इसके समाधान की खोज करने के क्रम में ऐसा लगता है कि यह समस्या आरटीएक्स श्रृंखला के साथ एक आम समस्या है (हालांकि यह क्यूडीए 10.0 के साथ एक सामान्य समस्या हो सकती है, क्योंकि नए कार्ड पुराने संस्करणों का समर्थन नहीं करते हैं)। यह बहुत अच्छा होगा यदि डिफॉल्ट को 1.13 की रिलीज़ में अपडेट किया जा सकता है ताकि इन कार्डों के लिए विशेष विकल्पों को सेट करने की आवश्यकता न हो।

यह कहते हुए कि मुझे निम्नलिखित विन्यास के तहत भी इसका अनुभव हुआ है:

• Https://github.com/tensorflow/benchmark से tf बेंचमार्क चलाना
• RTX 2080
• उबुन्टु 18.04
• सीयूडीए 10.0
• एनवीडिया ड्राइवर्स 415.27
• Tensorflow 1.13.0-dev20190125
• CuDNN 7.4.2
• अजगर ३

सब कुछ के स्थिर रिलीज के साथ Tensorflow Docker GPU कंटेनर या तो काम नहीं करते हैं (वे रिपोर्ट CUDNN_STATUS_INTERNAL_ERROR के बजाय सीधे segfault)।

उत्सुकता से, चीजें Tensorflow v1.12 के साथ विंडोज 10 पर ठीक काम करती हैं!

और दूसरों ने रिपोर्ट किया है, allow_growth सेट करने से चीज़ें ठीक से चल सकती हैं।

यहां भी यही समस्या।

• RTX 2070
• उबुन्टु 18.04
• CUDNN 7.4.2 (लेकिन मैंने बिना किसी भाग्य के अन्य पुराने संस्करणों के संकलन की कोशिश की है)
• Tensorflow 1.13.0-dev20190125 (Cuda 10 के साथ संकलित Tensorflow 1.12 भी आजमाया)

और जैसा कि अन्य लोगों ने बताया है, allow_growth = TRUE सेट करने से चीज़ें चल सकती हैं।

इस मुद्दे को अपने हल होने के बाद से बंद करना। धन्यवाद!

@ymodak क्या आप इस बग को ठीक करने वाले पीआर का संदर्भ

मैं RTX 2080 पर tf-nightly-gpu-2.0-preview साथ एक समान मुद्दा है

एक RTX2080 के साथ एक ही मुद्दा, दो दिन recompiling और बग शिकार बिताया जब तक मुझे यह ठीक नहीं मिला।
(allow_growth = सच्ची बात इसे तय करती है)

आपने मेरा दिन बना दिया

आप वास्तव में allow_growth = true को कैसे सेट करते हैं? मेरे पास tf-nightly-gpu-2.0-पूर्वावलोकन है और कोशिश की:

tf के रूप में आयात स्पर्शरेखा
config = tf.ConfigProto ()
config.gpu_options.allow_growth = सच
सत्र = tf.Session (config = config, ...)

लेकिन यह त्रुटि प्राप्त करें:

विशेषता ट्रेसेबैक (सबसे हालिया कॉल अंतिम)
में()
1 आयात tsorflow tf के रूप में
----> 2 विन्यास = tf.ConfigProto ()

गुण: मॉड्यूल 'टेंसरफ़्लो' में कोई विशेषता नहीं है 'विन्यास'

मैं अनुमार्गण 2.0 में allow_growth कैसे सेट कर सकता हूं?

ठीक है, इसे tf-nightly-gpu-2.0-प्रीव्यू में काम किया और ipython नोटबुक ने इसे मेरे कोड में जोड़ा:

Tetorflow.compat.v1 इंपोर्ट कॉन्फ़िगरेशनप्रोटो से
Tetorflow.compat.v1 से इंटरएक्टिव सत्र आयात करें

config = configProto ()
config.gpu_options.allow_growth = सच
सत्र = इंटरएक्टिव सत्र (विन्यास = विन्यास)

समान समस्या, gpu_options.allow_growth के साथ = सही समस्या ठीक की गई।

@newhouseb आपने सभी बेंचमार्क के लिए कैसे / कहाँ सेट किया है? क्या यह एक आसान बदलाव था?

क्या कंबल विकास को एक समाधान की अनुमति देता है?

एक कारण से इसे डिफ़ॉल्ट रूप से बंद कर दिया जाता है
https://www.tensorflow.org/guide/using_gpu#allowing_gpu_memory_growth

मेरे कार्यक्रम में स्मृति प्रबंधन महत्वपूर्ण है

मैं टीएफ द्वारा उपयोग किए जाने वाले जीपीयू की मात्रा को सीमित करना चाहता हूं क्योंकि मेरे ग्राफिक्स एप्लिकेशन में जीपीयू मेमोरी का उपयोग अन्य चीजों के लिए किया जाएगा और इसे एक सीमित स्थान पर रखना मेमोरी त्रुटियों से बचने के लिए महत्वपूर्ण है।

मैं विंडोज के तहत सी ++ में काम कर रहा हूं

OOM त्रुटि में अनुमति के विकास विकल्प के परिणाम को जोड़ना।

इस कोड की रेखा के बिना मॉडल एक ही कार्ड के साथ एक ही मशीन पर ठीक चलता है।

OOM त्रुटि के साथ

options.config.mutable_gpu_options()->set_allow_growth(true);
options.config.mutable_gpu_options()->set_per_process_gpu_memory_fraction(fraction);

OOM त्रुटि के बिना

//options.config.mutable_gpu_options()->set_allow_growth(true);
options.config.mutable_gpu_options()->set_per_process_gpu_memory_fraction(fraction);

तो सेट के साथ इस समस्या को हल करने के लिए एक segfault में विकास के परिणाम की अनुमति दें।

@ymodak यह बग ठीक नहीं किया गया है। यकीनन, किसी भी प्रकार के काफनेट का उपयोग करके डिफ़ॉल्ट कॉन्फ़िगरेशन में काम करना चाहिए। या तो allow_growth डिफ़ॉल्ट रूप से सही होना चाहिए, यह ठीक होना चाहिए इसलिए यह काम करता है, या CUDNN_STATUS_INTERNAL_ERROR तुलना में बेहतर त्रुटि होनी चाहिए।

@ymodak ऐसा लगता है कि यह मुद्दा समय से पहले बंद कर दिया गया था। जबकि इस मुद्दे के लिए एक काम के आसपास है इसमें एप्लिकेशन कोड बदलना शामिल है। परिणामस्वरूप उदाहरण कोड आरटीएक्स कार्ड पर बॉक्स_ के _out काम नहीं करता है और लाइन पर अधिकांश व्यंजनों को भी संशोधन की आवश्यकता होगी।

@samhodge आप अपने आप को पोस्ट किए गए टेंसरफ़्लो प्रलेखन पृष्ठ पर सुझाए गए config.gpu_options.per_process_gpu_memory_fraction = 0.4 का उपयोग करके OOM को नहीं रोक सकते?

मैं अपने RTX 2080 पर टेंसरफ़्लो-जीपीयू को सक्षम करने के लिए इस बूलियन हैक से भ्रमित हूं: क्या यह allow_growth = True एक मुद्दा होगा यदि मैं अपने GPU का उपयोग केवल एक टेंसरफ़्लो स्क्रिप्ट / ज्यूपिटर नोटबुक के लिए एक समय में करता हूं? (स्क्रीन आदि के लिए मानक GPU उपयोग के अतिरिक्त)

मैं एक कंप्यूटर पर एक स्थिर एमएल स्टैक सेट करने का इरादा रखता हूं और यह जानना चाहूंगा कि क्या यह किसी बिंदु पर गड़बड़ी (बड़े ग्रिडसर्च, कई मापदंडों वाले मॉडल आदि) में समाप्त हो जाएगा। मुझे अभी तक यह पता नहीं चला है कि इस आंतरिक त्रुटि से बचने के लिए या बस इस बूलियन को बदलने की कोशिश करने के लिए मुझे स्रोतों से निर्माण करने की आवश्यकता है या नहीं।

ठीक है, मुझे लगता है कि मैंने अपना सत्र बनाने से पहले अपने मुद्दों का स्रोत पाया था कि मैं GPU RAM को मुफ्त में मापता हूं, अगर मैं 8Gb कार्ड पर हूं और 6Gb स्वतंत्र हूं तो मैं 0.75 के अंश का उपयोग करता हूं और कभी-कभी एक OOM में समाप्त होता है लेकिन हाल ही में मैंने 0.95 * 0.75 के साथ प्रयोग कर रहा है और मेरे पास अभी भी एक OOM है। इसलिए यदि आप Tensorflow के आवंटन के लिए स्थान को धक्का देते हैं तो यह कभी-कभी सीमा तक सीमित हो जाता है। जाहिर है कि अगर आप किसी व्यक्ति से इनपुट और आउटपुट लेते हैं तो यह ओओएम फिट नहीं होता है, लेकिन मैं इसके खिलाफ मापता हूं कि कौन सा फिट बैठता है इसके आधार पर GPU या CPU का उपयोग करेगा।

@samhodge बहुत बढ़िया, इसलिए अंत में allow_growth बूलियन हैक एक समाधान प्रदान करता है यदि कोई प्रमुख GPU ऑपरेशन समानांतर में लॉन्च नहीं किया जाता है और यदि संसाधित किया जाता है, तो tsorflow द्वारा time_at_ (बैच आकार महत्वपूर्ण होगा) GPU द्वारा प्रदान की गई मेमोरी को ओवरफ्लो करें ...?

सब कुछ आपके ब्राउज़र को भी GPU का उपयोग करता है

CUDA 10.0 / cuDNN 7.4.2.24/Nvidia ड्राइवर 410 / Ubuntu 16.04 के साथ पाइप से टेंसरफ़्लो-जीपीयू 1.13.1 का उपयोग करके GTX 1050 पर एक ही अंक में चल रहा है।

अभी भी यहाँ एक ही समस्या है, लेकिन "config.gpu_options.allow_growth = True" समस्या को ठीक नहीं करता है। TF-gpu 1.14.1 और TF-gpu 2.0 दोनों पर होता है। RTX1070, CUDA 10.0, उबंटू 18.04, एनवीडिया ड्राइवर 430.09।

आपके द्वारा देखी जा रही समस्याओं का वर्णन मुझे विश्वास दिलाता है कि (विशेष संस्करण) cuDNN हैंडल बनाते समय GPU मेमोरी को आवंटित करने का प्रयास करता है। यदि TensorFlow ने पहले ही सभी मेमोरी ले ली है (या तो क्योंकि config.gpu_options.allow_growth = false, या per_process_gpu_memory_fraction 1.0 के करीब है) तो cuDNN को आवंटित करने के लिए कोई मेमोरी नहीं बची है।

आप nvprof के माध्यम से TensorFlow चलाकर इसकी पुष्टि कर सकते हैं और असफल cuMemAlloc कॉल का निरीक्षण करने के लिए एक एपीआई ट्रेस उत्पन्न कर सकते हैं।

समस्या # 6698 उसी समस्या पर चर्चा करती है। कुछ लोगों ने देखा कि उन्होंने गलती से एक cuDNN रिलीज़ का उपयोग किया था जो उनके CUDA संस्करण से मेल नहीं खाता। क्या आप यह सत्यापित कर सकते हैं कि CUDA 10 के साथ चलने पर आप CUDA 10 के लिए cuDNN का उपयोग कर रहे हैं?

मुझे पता है कि मैं cuDNN सही ढंग से स्थापित नहीं किया है क्योंकि मैं एक महान मूर्ख हूँ। TF2-nightly को पुन: स्थापित किया गया, वृद्धि की अनुमति देने के लिए लाइनें जोड़ी गईं, और यह सब अच्छा है।

कॉनडा से क्युडाटुलकिट और कुडन को कैसे हटाएं?

चूंकि एनाकोंडा-शामिल (या एम्बेडेड) cudnn में निम्नानुसार त्रुटि है, मैं कोंडा-स्थापित cudatoolkit और cudnn को निकालना चाहता हूं, और Nvidia की वेबसाइट से स्वतंत्र CUDA और cudnn स्थापित करना चाहता हूं।

त्रुटि: कन्वेंशन एल्गोरिथ्म प्राप्त करने में विफल। यह संभवतः इसलिए है क्योंकि cuDNN आरंभ करने में विफल रहा, इसलिए यह देखने की कोशिश करें कि क्या चेतावनी लॉग संदेश ऊपर मुद्रित किया गया था।

हालाँकि, जब मैं निम्नानुसार कमांड का उपयोग करता हूं, लेकिन उन्हें हटा नहीं सकता, मैं उन्हें हटा नहीं सकता।
conda remove --name कुडा - लंबा
conda remove --name cudnn --all

मैं देखता हूं कि रास्ते में cudatoolkit-10.0.130-0 और cudnn-7.3.1-cuda10.0.0_0 सहित दो दस्तावेज
इस प्रकार है।

/home/anaconda3/pkgs/cudatoolkit-10.0.130-0
/home/anaconda3/pkgs/cudnn-7.3.1-cuda10.0.0_0

मैं एनाकोंडा में शामिल (या एम्बेडेड) cuda और cudnn को कैसे (या हटा) सकता हूं।

अग्रिम में धन्यवाद,

माइक

@ mikechen66 कोंडा का आउटपुट क्या है? ऐसा इसलिए हो सकता है क्योंकि अन्य पैकेज क्यूडा और कॉड्न पर निर्भर करते हैं। आप उन्हें पहले स्थान पर क्यों हटाना चाहते हैं? यदि आप एक कस्टम वातावरण प्राप्त करना चाहते हैं, तो एनाकोंडा के बजाय मिनीकोन्डा का उपयोग करें। मिनिकोंडा केवल कोंडा के साथ आता है, और आपको उन सभी पैकेजों को स्थापित करने की आवश्यकता है जो आपको मैन्युअल रूप से चाहिए।

हाय tydlwav:

आपकी प्रतिक्रिया के लिए धन्यवाद। मुख्य पुस्तकालयों की संस्करण संगतता और रिलीज़ की तारीख की जांच करने के बाद, मैंने संबंधित देव वातावरण स्थापित किया, सरल MNIST परीक्षण कोड चलाया और निम्नानुसार आउटपुट प्राप्त किया।

मुझे लगता है कि एनाकोंडा 3 भी cudnn और TensorFlow के मुख्य पुस्तकालयों का समर्थन नहीं कर सकता है। तो यह एनाकोंडा 3 की एक बड़ी समस्या है। इसलिए मैं एनाकोंडा से हल्के कूडन पुस्तकालयों को हटाना चाहता हूं और परीक्षण कोड को चलाने के लिए स्वतंत्र और शक्तिशाली एनवीडिया क्यूडा और कुडनन पुस्तकालयों का उपयोग करना चाहता हूं। कृपया कुछ सुझाव देने में मदद करें।

1. स्थापना वातावरण

एनवीडिया GeForce RTX 2060
ग्राफिक्स ड्राइवर: NVIDIA-Linux-x86_64-415.27 (15 जनवरी, 2019)
1 संस्करण जो RTX 2060 का समर्थन करता है
एनाकोंडा 3: एनाकोंडा 3-2019.03-Luxux-x86_64.sh (2019.04-04)
- कुडाटुलकिट -१०ud.१.३०-0
- कुडन-7.3.1-cuda10.0.0_0
- तेंसोरलो १३.१
- जूप्यूटर नोटबुक और आईपाइकर्नल
- Ananconda3 द्वारा आक्रमण

1. MNIST टेस्ट कोड:

आयात करेस
keras.datasets से mnist आयात करें
keras.models से अनुक्रमिक आयात करते हैं
keras.layers से घने, ड्रॉपआउट आयात करते हैं
keras.layers से Flatten, MaxPooling2D, Conv2D आयात करते हैं
keras.callbacks से TensorBoard आयात करते हैं

(X_train, y_train), (X_test, y_test) = mnist.load_pata ()

X_train = X_train.reshape (60000,28,28,1) .astype ('flo3232)
X_test = X_test.reshape (10000,28,28,1) .astype ('float32)

X_train / = 255
X_test / = 255

n_classes = 10
y_train = keras.utils.to_categorical (y_train, n_classes)
y_test = keras.utils.to_categorical (y_test, n_classes)

मॉडल = अनुक्रमिक ()
model.add (Conv2D (32, kernel_size = (3,3), सक्रियण = 'relu', input_shape = (28,28,1)))
model.add (Conv2D (64, kernel_size = (3,3), सक्रियण = 'relu'))
model.add (MaxPooling2D (pool_size = (2,2)))
model.add (ड्रॉपआउट (0.25))
model.add (सपाट ())
model.add (घना (128, सक्रियण = 'रिले'))
model.add (ड्रॉपआउट (0.5))
model.add (घना (n_classes, सक्रियण = 'सॉफ्टमैक्स'))

model.compile (हानि = 'श्रेणीबद्ध_ सकल', ऑप्टिमाइज़र = 'एडैम', मेट्रिक्स = ['सटीकता'])

टेंसोर_बोर्ड = टेन्सरबोर्ड ('./ लॉग / लेनेट-एमएनआईएसटी -1')

model.fit (X_train, y_train, बैच_साइज = 128, युग = 15, क्रिया = 1,)
validation_data = (X_test, y_test), कॉलबैक = [टैंसर_बोर्ड])

1. आउटपुट:

TensorFlow बैकएंड का उपयोग करना।

चेतावनी: टेंसरफ़्लो : /home/mike/anaconda3/envs/tf-gpu/lib/python3.7/site-packages/tensorflow/python/framework/op_def_library.py:263: colocate_with (टेनसफ़्लो प्रवाह) से ) को हटा दिया गया है और भविष्य के संस्करण में हटा दिया जाएगा।
अद्यतन करने के निर्देश:
प्लेजर द्वारा कॉलोकेशन स्वचालित रूप से नियंत्रित किया जाता है।
चेतावनी: टेंसरफ़्लो: /home/mike/anaconda3/envs/tf-gpu/lib/python3.7/site-packages/keras/backend/tensorn_backend.py:3445: कॉलिंगआउट से (टेनसोरफ़्लोस्ट्रोथ.ऑन .nn_ops) Keep_prob के साथ पदावनत किया जाता है और भविष्य के संस्करण में हटा दिया जाएगा।
अद्यतन करने के निर्देश:
का उपयोग करें rate के बजाय keep_prob । दर rate = 1 - keep_prob सेट होनी चाहिए।
चेतावनी: टेंसरफ़्लो : /home/mike/anaconda3/envs/tf-gpu/lib/python3.7/site-packages/tensorflow/python/ops/math_ops.py:3066: to_int32 (from tanorflow.python.ops.math_ops_ops/ ) को हटा दिया गया है और भविष्य के संस्करण में हटा दिया जाएगा।
अद्यतन करने के निर्देश:
इसके बजाय tf.cast का प्रयोग करें।
60000 नमूनों पर ट्रेन, 10000 नमूनों पर मान्य
युग १/१५

अनजाने ट्रैसरबैक (सबसे हालिया कॉल अंतिम)
में
34
35 मॉडल
---> 36 सत्यापन_दाता = (एक्स_टेस्ट, वाई_टेस्ट), कॉलबैक = [टेंसोर_बोर्ड]]

~ / anaconda3 / envs / tf-gpu / lib / python3.7 / साइट-संकुल / keras / इंजन / प्रशिक्षण में फिट (स्व, x, y, batch_size, युगों, क्रियाओं, कॉलबैक, सत्यापन_एसपीएलटी, सत्यापन_दता, फेरबदल, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, ** kwargs)
1037 आरंभिक_पॉच = आरंभिक_चोच,
1038 चरण_पर_पॉच = चरण_पर_पुछ,
-> 1039 सत्यापन_स्टेप = सत्यापन_स्टेप्स)
1040 है
1041 डीईए मूल्यांकन (स्वयं, x = कोई नहीं, y = कोई नहीं,

~ / anaconda3 / envs / tf-gpu / lib / python3.7 / site-package / keras / engine / training_arrays.py to fit_loop (मॉडल, f, ins, out_labels, batch_size, epochs, verbose, callbacks, val_f, val_ins) फेरबदल, कॉलबैक_मेट्रिक्स, आरंभिक_पॉच, स्टेप्स_पर_प्रोच, सत्यापन_स्टेप्स)
197 ins_batch [i] = ins_batch [i] .toarray ()
198
-> 199 बहि = f (ins_batch)
200 बाहरी = to_list (बाहरी)
201 for l, o in zip (out_labels, outs):

~ / anaconda3 / envs / tf-gpu / lib / python3.7 / साइट-संकुल / keras / बैकएंड / tanorflow_backend.py __call __ (स्वयं, इनपुट)
2713 स्व वापस लौटें।
2714
-> 2715 स्व।
2716 और:
2717 यदि इनपुट में x के लिए py_any (is_tensor (x)):

~ / anaconda3 / envs / tf-gpu / lib / python3.7 / साइट-पैकेज / केरेस / बैकएंड / tanorflow_backend.py_call (स्वयं, इनपुट)
2673 लाया गया = self._callable_fn ( array_vals, run_metadata = self.run_metatata)2674 और:-> 2675 मिले = स्व।
2676 लौटे [: len (self.outputs)]
2677

~ / anaconda3 / envs / tf-gpu / lib / python3.7 / साइट-पैकेज / टेंसरफ़्लो / पायथन / क्लाइंट / सेशन __call __ (स्वयं, args, * kwargs) में
1437 रिट = tf_session.TF_SessionRunCallable (
1438 self._session._session, self._handle, args, स्थिति,
-> 1439 run_metadata_ptr)
1440 यदि run_metadata:
1441 प्रोटो_डाटा = tf_session.TF_GetBuffer (run_metadata_ptr)

~ / anaconda3 / envs / tf-gpu / lib / python3.7 / साइट-पैकेज / टेंसरफ़्लो / python / फ्रेमवर्क / त्रुटियाँ_impl.py में __exit __ (स्वयं, type_arg, value_arg, ट्रेसबैक_arg)
526 कोई नहीं, कोई नहीं,
527 कंपेटर्स ।as_text (c_api.TF_Message (self.status.status)),
-> 528 c_api.TF_GetCode (self.status.status))
529 # अंतर्निहित स्थिति ऑब्जेक्ट को स्मृति से हटा दें अन्यथा यह जीवित रहता है
530 # के रूप में ट्रेसबैक से इस से स्थिति का संदर्भ है

UnknownError: कनवल्शन एल्गोरिथ्म प्राप्त करने में विफल। यह संभवतः इसलिए है क्योंकि cuDNN आरंभ करने में विफल रहा, इसलिए यह देखने की कोशिश करें कि क्या चेतावनी लॉग संदेश ऊपर मुद्रित किया गया था।
[[{{नोड conv2d_1 / कनवल्शन}}]]
[[{{नोड मैट्रिक्स / एसीसी / मीन}}]]

हाय tydlwav:

मैं cuda और cudnn दोनों को अनइंस्टॉल करने के लिए निम्न कमांड का उपयोग करता हूं। हालाँकि, दोनों पुस्तकालय अभी भी एनाकोंडा 3 में स्थित हैं, हालांकि वे अभी काम नहीं करते हैं। मुझे लगता है कि एनाकोंडा 3 को हटाने के लिए मुख्य पुस्तकालयों की रक्षा करना चाहता है। यह कॉन्टिनम की मुख्य क्षमता भी हो सकती है, यहां तक ​​कि यह भी बग है। मैं या तो स्वतंत्र एनवीडिया क्यूडा (निराधार एनसीसीसी) और कुडन का उपयोग करने की कोशिश करूंगा या नए कोडा या कुडनन को कोंडा स्थापित करने के लिए खोजूंगा।

स्थापना रद्द करें आदेश:

conda स्थापना रद्द करें

पैकेज मेटाडेटा एकत्रित करना: किया गया
पर्यावरण को हल: किया

पैकेज योजना

पर्यावरण स्थान: / घर / माइक / anaconda3 / envs / tf-gpu

हटाए गए ऐनक:
- कुडाटुलकिट

निम्नलिखित पैकेज याद किए जाएंगे:

cudatoolkit-10.0.130-0
cudnn-7.3.1-cuda10.0_0
कपटी- 10.0.130-0
केर-2.2.4-0
टेंसरफ़्लो 1.13.1-gpu_py37hc158e3b_0
टेनसफ़्लो-बेस-1.13.1-gpu_py37h8d69cac_0
टेंसरफ़्लो-जीपीयू-1.13.1-h0d30ee6_0

आगे बढ़ें ([y] / n)? य

लेनदेन तैयार करना:
लेन-देन का सत्यापन: किया गया
निष्पादित लेनदेन: किया गया

टिप्पणियाँ:

जब मैंने दोनों को अनइंस्टॉल किया, तब जुपिटर नोटबुक में "टेनसफ़्लो" नाम का कोई मैड्यूल नहीं दिखाया गया। इसका मतलब यह है कि असंबद्धता सफल है। हालांकि, दोनों cudatoolkit और cudnn अभी भी एनाकोंडा 3 में पाए जाते हैं। मुझे लगता है कि कॉन्टिनम उन्हें हटाने के लिए नहीं, हालांकि दोनों को हटाने के लिए नहीं। उन्हें काम नहीं आता।

/home/anaconda3/pkgs/cudatoolkit-10.0.130-0
/home/anaconda3/pkgs/cudnn-7.3.1-cuda10.0.0_0

आप उन्हें पहले ही निकाल चुके हैं। pkgs की फाइलें इंस्टॉलेशन के लिए हैं। इन्हें इंस्टॉलेशन के लिए कैश डाउनलोड किया जाता है। इसके अलावा, यह कोंडा पर्यावरण के मुद्दों पर चर्चा करने का स्थान नहीं है। यह इस मुद्दे के लिए प्रासंगिक नहीं है। आप स्टैक ओवरफ्लो की कोशिश करना चाह सकते हैं।

मैं इस मुद्दे की स्थिति से थोड़ा भ्रमित हूं। मैं एक RTX 2080, cuda 10.1, cudnn v7.5.1.10 और टेंसरफ्लो 1.14 का उपयोग कर रहा हूं।

काम के आसपास विकास की अनुमति के काम का उपयोग करना, लेकिन शायद मेरे पास एक अलग संस्करण बेमेल है?

क्या टेनसफ़्लो 1.14 में इसके लिए कोई फिक्स होगा?

धन्यवाद

धन्यवाद। मैं RTX 20XX ट्यूरिंग श्रृंखला, टेंसोरफ्लो और एनाकोंडा के बीच संगतता मुद्दे को देखता हूं। यह स्पष्ट है कि RTX 20XX श्रृंखला cudnn 7.5.0 का समर्थन करती है, TensorFlow केवल cudnn 7.4 का समर्थन करता है, लेकिन एनाकोंडा में एक सुव्यवस्थित 7.3.1 शामिल है, यह तीन विक्रेताओं के बीच कुल बेमेल है। इसके अलावा, RTX 20XX श्रृंखला में Ubuntu 16.04 LTS के साथ एक बड़ी संगतता समस्या है। कभी-कभी, Ubuntu 16.04 दुर्घटनाग्रस्त हो गया। ओएस को फिर से स्थापित करने के लिए मुझे दो बूट करने योग्य यूएसबी स्टिक लाने पड़े। इसलिए, मैंने दो पीसी को उबंटू 18.04 एलटीएस में अपग्रेड किया और मिनिकोंडा स्थापित किया। तब मैं एक उच्च संस्करण Tensorflow की कोशिश करूँगा।

टिप्पणियाँ:

Nvidia के पास अपने Jetson TX1 / TX2 और Jetson नैनो मोबाइल GPU प्लेटफॉर्म के लिए अपना खुद का कस्टम Ubuntu 18.04 LTS है। एनवीडिया अपने नए उत्पादों जैसे कि आरटीएक्स 20XX श्रृंखला को उबंटू 18.04 एलटीएस के साथ संगतता में निर्धारित करता है, बजाय निचले संस्करण उबंटू 20.04 के साथ। हालाँकि, मुझे नहीं पता कि कॉन्टिनम में एनवीडिया आरटीएक्स 20 एक्सएक्स ट्यूरिंग सीरीज़ की अपनी अपग्रेड योजना है या नहीं।

RTX श्रृंखला को इस समय अच्छी तरह से समर्थित किया गया है। मैंने गैर-उबंटू वितरण पर एक कोंडा पर्यावरण के माध्यम से RTX 2070 के साथ tf का उपयोग किया है। यह सबसे खराब स्थिति होना चाहिए, और यह अभी भी ठीक काम कर रहा है। Cuda और cudnn पीछे की ओर संगत हैं, और यदि आप नए संस्करणों का उपयोग करते हैं तो यह एक मुद्दा नहीं होना चाहिए। आपको बस conda create -n tf python==3.6.8 साथ एक नया Python 3.6 वातावरण बनाना चाहिए और conda install tensorflow-gpu चलाना चाहिए।

यह महान है जिसे मैंने स्रोत से संकलित किया है और अधिकांश हार्डवेयर पर Tensorflow 1.12.0 CUDA 10.0 और CUDNN 7.4.2.24 के साथ क्लाइंट काम किया है, लेकिन मेरे पास कई मुट्ठी भर ग्राहकों के साथ RTX कार्ड्स के साथ CNNN के साथ GPU पर cudnn है। मैंने गलती से CUDA 9.0 के लिए गलत CUDNN पैक कर दिया हो सकता है, फाइलों को नाम दिया गया है।

क्या कोई पुष्टि कर सकता है कि ये संस्करण RTX2080 और अन्य ट्यूरिंग आधारित कार्ड पर काम करते हैं?

हाय tydlwav:

मैंने आपके सुझाव के अनुसार मिनिकोंडा और संबंधित अजगर और टेंसोरफ़्लो वातावरण स्थापित किया। इसमें अभी भी त्रुटि है: कन्वेंशन एल्गोरिथम प्राप्त करने में विफल। यह शायद इसलिए है क्योंकि cuDNN शुरू करने में विफल रहा है ......।
कृपया कोई हल खोजने में मदद करें।

कृपया मेरे द्वारा संचालित चरण देखें।

1. अपने गाइडलाइन के अनुसार इंस्टाल अजगर 3.6.8।
   conda create -n tf python == 3.6.8

2. सक्रिय करें
   conda सक्रिय tf

3. अपने दिशानिर्देश के अनुसार tf वातावरण में टेंसरफ़्लो-जीपीयू स्थापित करें।
   कोंडा टेंसरफ़्लो-जीपीयू स्थापित करें

स्थापित पैकेज में निम्नानुसार cudatoolkit और cudnn शामिल हैं।
……………………………………………। ……………………………………………।
cudatoolkit pkgs / main / linux-64 :: cudatoolkit-10.0.130-0
cudnn pkgs / main / linux-64 :: cudnn-7.3.1-cuda10.0_0
……………………………………………। ……………………………………………।

1. वेबपेज पर ज्यूपिटर नोटबुक, आईपीक्युलर और संबंधित वातावरण स्थापित करें।

1)। बृहस्पति नोटबुक स्थापित करें
conda jupyter नोटबुक स्थापित करें

२)। ज्यूपिटर नोटबुक के आधार पर आईपार्कल स्थापित करें
conda इंस्टॉल करें

३)। Jupyter नोटबुक के वेबपेज में TensorFlow-GPU बनाएँ
python -m ipykernel install --user --name tf-gpu --display-name "TensorFlow-GPU"

1. जूपिटर नोटबुक खोलें
   1)। jupyter नोटबुक वेबपेज में कमांड
   ज्यूपिटर नोटबुक

२)। TensorFlow-GPU पर क्लिक करें
मेनू में "नया" और "पेज में टेंसोरफ्लो-जीपीयू" का चयन करते समय, सेल ज्यूपिटर नोटबुक के वेबपेज में दिखाई देता है। वेबपेज इस प्रकार सूचीबद्ध है।
http: // localhost : 8888 / नोटबुक्स / अनटाइटलड 3.ipynb? कर्नेल_नाम = tf-gpu?

1. सरल MNIST परीक्षण कोड चलाएँ

आयात करेस
keras.datasets से mnist आयात करें
keras.models से अनुक्रमिक आयात करते हैं
keras.layers से घने, ड्रॉपआउट आयात करते हैं
keras.layers से Flatten, MaxPooling2D, Conv2D आयात करते हैं
keras.callbacks से TensorBoard आयात करते हैं

(X_train, y_train), (X_test, y_test) = mnist.load_pata ()

X_train = X_train.reshape (60000,28,28,1) .astype ('flo3232)
X_test = X_test.reshape (10000,28,28,1) .astype ('float32)

X_train / = 255
X_test / = 255

n_classes = 10
y_train = keras.utils.to_categorical (y_train, n_classes)
y_test = keras.utils.to_categorical (y_test, n_classes)

मॉडल = अनुक्रमिक ()
model.add (Conv2D (32, kernel_size = (3,3), सक्रियण = 'relu', input_shape = (28,28,1)))
model.add (Conv2D (64, kernel_size = (3,3), सक्रियण = 'relu'))
model.add (MaxPooling2D (pool_size = (2,2)))
model.add (ड्रॉपआउट (0.25))
model.add (सपाट ())
model.add (घना (128, सक्रियण = 'रिले'))
model.add (ड्रॉपआउट (0.5))
model.add (घना (n_classes, सक्रियण = 'सॉफ्टमैक्स'))

model.compile (हानि = 'श्रेणीबद्ध_ सकल', ऑप्टिमाइज़र = 'एडैम', मेट्रिक्स = ['सटीकता'])

टेंसोर_बोर्ड = टेन्सरबोर्ड ('./ लॉग / लेनेट-एमएनआईएसटी -1')

model.fit (X_train, y_train, बैच_साइज = 128, युग = 15, क्रिया = 1,)
validation_data = (X_test, y_test), कॉलबैक = [टैंसर_बोर्ड])

1. पिछले संदेश के समान ही त्रुटियां:

UnknownError: कनवल्शन एल्गोरिथ्म प्राप्त करने में विफल। यह संभवतः इसलिए है क्योंकि cuDNN आरंभ करने में विफल रहा, इसलिए यह देखने की कोशिश करें कि क्या चेतावनी लॉग संदेश ऊपर मुद्रित किया गया था।
[[{{नोड conv2d_1 / कनवल्शन}}]]
[[{{नोड मैट्रिक्स / एसीसी / मीन}}]]

धन्यवाद,

माइक

HI tydlwav:

वैसे, मैंने निम्नलिखित कमांड के साथ केरस भी स्थापित किया।
conda इंस्टॉल करें

चूंकि कभी स्थापना सही है, मुझे त्रुटि मिली है। इसलिए मुझे लगता है कि यह Miniconda और RTX20XX ट्यूरिंग श्रृंखला के बीच संस्करण संगतता समस्या है। त्रुटि एनाकोंडा के समान है। मुझे पता चला है कि मिनिकोंडा और एनाकोंडा में क्यूडन और क्यूडा संस्करण समान हैं।

यह काफी दिलचस्प है। मुझे लगभग 10 और cudnn7.3 को लगभग डेढ़ महीने पहले कोंडा के साथ काम करना पड़ा। मैंने तब से टेंसरफ़्लो का उपयोग नहीं किया है। यदि यह आपके लिए काम नहीं करता है, तो आप स्रोत से निर्माण कर सकते हैं। वह हमेशा मेरे लिए काम करता है। यदि आप अभी शुरू कर रहे हैं, तो मैं pytorch का उपयोग करने की सलाह दूंगा। आपके पास काम करने और काम करने में बहुत आसान समय होगा।

हाय tydlwav:

मैं अन्य विधि की कोशिश करूँगा जैसे कि पाइटोरेक। अब जब Google टेनसफ़्लो-जीपीयू 1.14 जारी करता है, तो क्या मैं निम्न टेनसफ़्लो-जीपीयू 1.14 को Google टेंसरफ़्लो वेबसाइट पर निम्नानुसार स्थापित करने के लिए मिनिकोंडा का उपयोग कर सकता हूं।

Google टेंसरफ़्लो: https://www.tensorflow.org/install/source

टिप्पणियाँ:

कॉनडा के पास केवल टेंसरफ्लो-जीपीयू है जो 1.0.1 से 1.13.1 तक निम्नानुसार है। बिल्ड इतने पुराने हैं कि बिल्ड आधिकारिक Google TensorFlow और आधिकारिक Nvidia GeForce RTX 20XX (2060 ~ 2080) Truing श्रृंखला के साथ पकड़ नहीं सके।

आदेश:
कोंडा खोज टेंसरफ़्लो-जीपीयू

चैनल लोड हो रहा है: किया

नाम संस्करण बिल्ड चैनल
टेंसरफ्लो- gpu 1.0.1 py27_4 pkgs / मुफ्त
टेंसरफ्लो- gpu 1.0.1 py35_4 pkgs / मुफ्त
टेंसरफ़्लो-gpu 1.0.1 py36_4 pkgs / मुफ्त
टेंसरफ्लो-जीपीयू 1.1.0 np111py27_0 pkgs / मुफ्त
टेंसरफ्लो-जीपीयू 1.1.0 np111py35_0 pkgs / मुफ्त
टेंसरफ्लो-जीपीयू 1.1.0 np111py36_0 pkgs / मुफ्त
टेंसरफ्लो-जीपीयू 1.1.0 np112py27_0 pkgs / मुफ्त
टेंसरफ्लो-जीपीयू 1.1.0 np112py35_0 pkgs / मुफ्त
टेंसरफ्लो-जीपीयू 1.1.0 np112py36_0 pkgs / मुफ्त
टेंसरफ्लो-जीपीयू 1.2.1 py27cuda7.5cudnn5.1_0 pkgs / मुफ्त
टेंसरफ्लो-जीपीयू 1.2.1 py27cuda7.5cudnn6.0_0 pkgs / मुफ्त
टेंसरफ्लो-जीपीयू 1.2.1 py27cuda8.0cudnn5.1_0 pkgs / मुफ्त
टेंसरफ्लो-जीपीयू 1.2.1 py27cuda8.0cudnn6.0_0 pkgs / मुफ्त
टेंसरफ्लो-जीपीयू 1.2.1 py35cuda7.5cudnn5.1_0 pkgs / मुफ्त
टेंसरफ्लो-जीपीयू 1.2.1 py35cuda7.5cudnn6.0_0 pkgs / मुफ्त
टेंसरफ्लो-जीपीयू 1.2.1 py35cuda8.0cudnn5.1_0 pkgs / मुफ्त
टेंसरफ्लो-जीपीयू 1.2.1 py35cuda8.0cudnn6.0_0 pkgs / मुफ्त
टेंसरफ्लो-जीपीयू 1.2.1 py36cuda7.5cudnn5.1_0 pkgs / मुफ्त
टेंसरफ्लो-जीपीयू 1.2.1 py36cuda7.5cudnn6.0_0 pkgs / मुफ्त
टेंसरफ़्लो-जीपीयू 1.2.1 py36cuda8.0cudnn5.1_0 pkgs / मुफ्त
टेंसरफ्लो-जीपीयू 1.2.1 py36cuda8.0cudnn6.0_0 pkgs / मुफ्त
टेंसरफ्लो-जीपीयू 1.3.0 0 पीकेजी / मुक्त
टेंसरफ्लो-जीपीयू 1.4.1 0 pkgs / main
टेंसरफ्लो-जीपीयू 1.5.0 0 पीकेजी / मुख्य
टेंसरफ्लो-जीपीयू 1.6.0 0 pkgs / main
टेंसरफ्लो-जीपीयू 1.7.0 0 पीकेजी / मुख्य
टेंसरफ्लो-जीपीयू 1.8.0 h7b35bdc_0 pkgs / main
टेंसरफ्लो-जीपीयू 1.9.0 hf154084_0 pkgs / main
टेंसरफ्लो-जीपीयू 1.10.0 hf154084_0 pkgs / main
टेंसरफ़्लो-जीपीयू 1.11.0 h0d30ee6_0 pkgs / main
टेंसरफ्लो-जीपीयू 1.12.0 h0d30ee6_0 pkgs / main
टेंसरफ्लो-जीपीयू 1.13.1 h0d30ee6_0 pkgs / main

वे पुराने नहीं हैं, जैसा कि मैंने RTX 2070 के साथ tf 1.12 के conda की रिलीज़ का उपयोग किया है। नए हार्डवेयर आमतौर पर पिछड़े संगत होते हैं, और RTX अलग नहीं होते हैं। यह सबसे अधिक संभावना है कि खेल में कुछ अजीब पर्यावरण के मुद्दे हैं। मेरे पास जुलाई तक आरटीएक्स मशीन का उपयोग नहीं है, इसलिए मैं अभी परीक्षण में मदद नहीं कर सकता। स्रोत से बिल्डिंग आपकी समस्या को हल करना चाहिए। मैं स्रोत से निर्मित tf से काफिले को चलाने में कभी असफल नहीं रहा (यह मानकर कि आपके पास बिल्ड के दौरान सही कॉन्फ़िगरेशन है)।

एक बार फिर, यह टेंसोफ़्लो के वितरण मुद्दे पर चर्चा करने के लिए सही जगह नहीं है। आप स्टैक ओवरफ्लो या रेडिट पर एक पोस्ट बना सकते हैं और इसे यहां लिंक कर सकते हैं। अधिक लोग इसे देख पाएंगे और इस तरह से आपकी मदद करेंगे।

आपका मुद्दा बग नहीं है, और यह निश्चित रूप से नहीं है कि यह मुद्दा क्या है।

@chsigg आप निदान कर रहे हैं कि यह एक समस्या w / CUDNN है जो कि GPU मेमोरी संसाधनों को आवंटित करने का प्रयास कर रहा है जो कि पहले से ही आबंटित है, मुझे सही लगता है। बस per_process_gpu_memory_fraction=0.9 बजाय 0.95 करना मेरे मुद्दों को हल करने के लिए पर्याप्त था।

मैं भी इस मुद्दे का सामना कर रहा था। इसे cuDNN को 7.6 संस्करण में अपडेट करके तय किया।

tensorflow.python.framework.errors_impl.UnknownError: Failed to get convolution algorithm. This is probably because cuDNN failed to initialize, so try looking to see if a warning log message was printed above

टेंसोफ़्लो-जीपीयू: 1.13.1
कूडा: 10.0
CuDNN: 7.3.1

इसके अलावा, टेनडोफ़्लो और CuDNN कोनदा द्वारा स्थापित किया गया था।
conda list cudnn

cudnn                     7.3.1                cuda10.0_0    anaconda

चीजें जो मैंने कीं:

1. अनइंस्टॉल किया गया कोंडा टेंसरफ़्लो।
   conda remove tensorflow
2. Conda cuDNN की स्थापना रद्द करें
   conda remove cudnn
3. पाइप के साथ टेंसरफ्लो स्थापित करें
   pip install tensorflow
4. Https://developer.nvidia.com/cudnn से संबंधित cuDNN 7.6 रनटाइम डिबेट फ़ाइल डाउनलोड करें
5. इसे sudo dpkg -i libcudnn_xxxxx_amd64.deb साथ स्थापित करें

@nluehr कोई टिप्पणी? क्या हम MinSystemMemory () cuda / cudnn संस्करण से अवगत करा सकते हैं?

यह एक मेमोरी त्रुटि है, यदि tf.keras का उपयोग कर रहे हैं तो अपनी फ़ाइल के शीर्ष पर निम्न कार्य करें
config = tf.ConfigProto ()
config.gpu_options.allow_growth = सच
tf.keras.backend.set_session (tf.Session (config = config))

मैं इस मुद्दे में भी भाग गया, और @ va-andrew के समाधान का उपयोग करके इसे हल करने में सक्षम था, और विशेष रूप से, मैंने @colinsteidtmann के कार्यान्वयन का उपयोग किया था, क्योंकि मैं अपने कोड में कुछ टेंसोफ़्लोअर.केयर फ़ंक्शंस का उपयोग करता हूं। मैंने इस समस्या को दूर करने के लिए एक लंबा समय बिताया, इसलिए आपके योगदान के लिए दोनों को धन्यवाद।

संपादित करें: मैं केवल टेंसरफ़्लो दस्तावेज़ (https://www.tensorflow.org/guide/use_gpu) देख रहा था, और आप इसे पर्यावरण चर TF_FORCE_GPU_ALLP_GROWTH को सत्य के रूप में सेट करके मेमोरी वृद्धि की अनुमति देने के लिए भी कह सकते हैं। यह यह भी कहता है कि यह कॉन्फ़िगरेशन प्लेटफ़ॉर्म विशिष्ट है, इसलिए YMMV (Ubuntu 18.04 के साथ मेरे लिए काम करता है)।

संदर्भ के लिए, मैं भाग रहा हूं:
Ubuntu 18.04.2 LTS, गीगाबाइट GeForce RTX 2080 टर्बो, NVIDIA ड्राइवर 430.26, CUDA 10.0.130, cuDNN 7.4.2.24, टेंसरफ़्लो-जीपीयू 1.13.1, पायथे 3.6। मैं स्पाइडर 3.3.4 का उपयोग करके एक आभासी वातावरण के भीतर से टेंसरफ्लो चलाता हूं।

मेरे पास उसी हार्डवेयर के साथ एक दूसरा कंप्यूटर है, और मैंने इसे सेट किया है निर्देशों के एक ही सेट के बाद, इंस्टॉल करने के लिए समान फ़ाइलों का उपयोग किया, और उस मशीन पर भी यह समस्या थी। कोई आश्चर्य नहीं।

मेरे पास ठीक उसी हार्डवेयर वाला एक तीसरा कंप्यूटर है, सिवाय इसके कि इसमें 2080 के बजाय 2080 तिवारी है, और मैंने इसे निर्देशों के एक ही सेट के बाद सेट किया, और फिर से इन्स्टॉल करने के लिए उन्हीं फाइलों का इस्तेमाल किया। लेकिन इस बार, कोई मुद्दा नहीं था।

इसलिए, मुझे विश्वास है कि यह CUDA, cuDNN और ड्राइवर संस्करण के कुछ संघर्षों से संबंधित नहीं है; यह गलत तरीके से किया गया इंस्टॉलेशन नहीं है, बल्कि यह वीडियो कार्ड के मॉडल से संबंधित है; मैंने केवल RTX 2060, 2070 और 2080 के साथ इस मुद्दे का उल्लेख देखा है।

सौभाग्य से, यह वर्कअराउंड का उपयोग करने के लिए एक बड़ी असुविधा नहीं है।

मैं भी इस मुद्दे का सामना कर रहा था। इसे cuDNN को 7.6 संस्करण में अपडेट करके तय किया।

tensorflow.python.framework.errors_impl.UnknownError: Failed to get convolution algorithm. This is probably because cuDNN failed to initialize, so try looking to see if a warning log message was printed above

टेन्सफ़्लोफ़: 1.13.1
कूडा: 10.0
CuDNN: 7.3.1

इसके अलावा, टेनडोफ़्लो और CuDNN कोनदा द्वारा स्थापित किया गया था।
conda list cudnn

cudnn                     7.3.1                cuda10.0_0    anaconda

चीजें जो मैंने कीं:

1. Uninstalled conda tensorflow.
   `conda remove tensorflow`

2. Uninstall conda cuDNN
   `conda remove cudnn`

3. Install tensorflow with pip
   `pip install tensorflow`

4. Download corresponding cuDNN 7.6 runtime deb file from https://developer.nvidia.com/cudnn

5. Install it with `sudo dpkg -i libcudnn7_-1+cuda9.0_amd64.deb`

@ alexforever86 आपने अपना अपडेट करने के बाद, क्या आप सुनिश्चित हैं कि आप अपने GPU पर चल रहे हैं, और CPU नहीं? ऐसा लगता है कि आप अपना अपडेट करने से पहले GPU का उपयोग कर रहे हैं (त्रुटि संदेश cuDNN को संदर्भित करने के कारण), लेकिन मैं इसके बारे में आश्चर्य करता हूं। आप "पाइप स्थापित टेंसोफ़्लो" का उपयोग करते हैं, लेकिन यह "पिप इंस्‍टॉल टेंसोरफ़्लो-जीपीयू" होना चाहिए, नहीं? इसके अलावा, आपने कहा कि आप CUDA 10 का उपयोग कर रहे हैं, लेकिन आपके द्वारा सूचीबद्ध cuDNN डिबेट cuda9.0 के लिए है, इसलिए मुझे यह काम नहीं करना चाहिए।

इसलिए, मुझे लगता है कि यह मामला हो सकता है कि आप वास्तव में GPU का उपयोग नहीं कर रहे हैं, और इस तरह यह सबूत नहीं है कि cuDNN 7.6 में अपडेट करना समस्या का समाधान करता है।

@ synapse8 आप टेंसरफ़्लो-gpu और cuDNN संस्करण के बारे में बिल्कुल सही हैं। मैं अब अपनी टिप्पणी से बहुत अधिक भ्रमित हूं, और मुझे अब विवरण याद नहीं है। वैसे भी, नीचे दिए गए मेरे सिस्टम में वर्तमान संस्करण हैं।

pip show tensorflow-gpu
नाम: टेंसोफ़्लो-जीपीयू
संस्करण: 1.13.1

nvidia-smi
NVIDIA-SMI 430.26 चालक संस्करण: 430.26 CUDA संस्करण: 10.2

sudo apt search cudnn | grep installed
libcudnn7 / अब 7.6.0.64-1 + cuda10.0 amd64

@ alexforever86 अब आपके द्वारा बताए गए कॉन्फ़िगरेशन के साथ आप अभी भी इस समस्या को देखते हैं? (मुझे लगता है कि यह आपके लिए काम करता है)। मैंने हाल ही में cuda10, 410 ड्राइवर, 7.6 cudnn और TF-gpu 1.14 (पाइप स्थापित) के साथ एक सिस्टम स्थापित किया है और इस मुद्दे को नहीं देखा है।

@ robzor92 मैं टेंसरफ़्लो-जीपीयू 1.13 का उपयोग कर रहा हूं, और जिज्ञासा से बाहर, मैंने अभी परीक्षण करने के लिए 1.14 स्थापित किया है अगर यह समस्या हल हो गई (मेरे लिए)। मैं अभी भी त्रुटि प्राप्त कर रहा हूं, और अभी भी 'विकास को अनुमति दें' को हल करने के लिए है (फिर से, इतना बड़ा सौदा नहीं)।

आप किस वीडियो कार्ड का उपयोग कर रहे हैं?

@ synapse8 ने GTX 1070 के साथ

@ synapse8 मैंने इस थ्रेड क्रिएटर द्वारा प्रदान किए गए सैंपल कोड को अभी-अभी आज़माया, यह बिना किसी समस्या के काम करता है। हालांकि मैं यह दावा नहीं करूंगा कि यह केवल RTX लाइन की समस्या है क्योंकि मैंने GTX 1050Ti पर TF 1.13.1 के साथ यही समस्या देखी थी। उसी ड्राइवर / क्यूडा / कॉडन संयोजन का उपयोग करना जो मैंने पहले पोस्ट किया था।

@ robzor92 मुझे संदेह है कि 1050Ti की समस्या छोटे VRAM आकार के साथ है। RTX कार्ड इसका मूल CNN MNIST मॉडल पर सामना करेंगे। मुझे संदेह है कि यह आरवीएक्स कार्डों पर वीआरएएम आवंटन की एनवीआईडीआईए की ट्विकिंग है जिसने किसी तरह चीजों को गड़बड़ कर दिया है।

मुझे टेनसफ़्लो 1.14.0 और RTX2080 पर समान त्रुटि है। लेकिन मेरे मामले में, यह त्रुटि तब होती है जब मैं कनवल्शन लेयर का उपयोग करता हूं।

2019-07-14 21:48:13.041683: I tensorflow/core/platform/cpu_feature_guard.cc:142] Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX2 FMA
2019-07-14 21:48:13.064262: I tensorflow/core/platform/profile_utils/cpu_utils.cc:94] CPU Frequency: 3600000000 Hz
2019-07-14 21:48:13.064955: I tensorflow/compiler/xla/service/service.cc:168] XLA service 0x55abe99bcd30 executing computations on platform Host. Devices:
2019-07-14 21:48:13.064967: I tensorflow/compiler/xla/service/service.cc:175]   StreamExecutor device (0): <undefined>, <undefined>
2019-07-14 21:48:13.066219: I tensorflow/stream_executor/platform/default/dso_loader.cc:42] Successfully opened dynamic library libcuda.so.1
2019-07-14 21:48:13.153748: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:1005] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2019-07-14 21:48:13.154195: I tensorflow/compiler/xla/service/service.cc:168] XLA service 0x55abebb44f00 executing computations on platform CUDA. Devices:
2019-07-14 21:48:13.154207: I tensorflow/compiler/xla/service/service.cc:175]   StreamExecutor device (0): GeForce RTX 2080, Compute Capability 7.5
2019-07-14 21:48:13.154317: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:1005] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2019-07-14 21:48:13.154707: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1640] Found device 0 with properties: 
name: GeForce RTX 2080 major: 7 minor: 5 memoryClockRate(GHz): 1.71
pciBusID: 0000:01:00.0
2019-07-14 21:48:13.154845: I tensorflow/stream_executor/platform/default/dso_loader.cc:42] Successfully opened dynamic library libcudart.so.10.0
2019-07-14 21:48:13.155504: I tensorflow/stream_executor/platform/default/dso_loader.cc:42] Successfully opened dynamic library libcublas.so.10.0
2019-07-14 21:48:13.156112: I tensorflow/stream_executor/platform/default/dso_loader.cc:42] Successfully opened dynamic library libcufft.so.10.0
2019-07-14 21:48:13.156265: I tensorflow/stream_executor/platform/default/dso_loader.cc:42] Successfully opened dynamic library libcurand.so.10.0
2019-07-14 21:48:13.157040: I tensorflow/stream_executor/platform/default/dso_loader.cc:42] Successfully opened dynamic library libcusolver.so.10.0
2019-07-14 21:48:13.157646: I tensorflow/stream_executor/platform/default/dso_loader.cc:42] Successfully opened dynamic library libcusparse.so.10.0
2019-07-14 21:48:13.159661: I tensorflow/stream_executor/platform/default/dso_loader.cc:42] Successfully opened dynamic library libcudnn.so.7
2019-07-14 21:48:13.159730: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:1005] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2019-07-14 21:48:13.160165: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:1005] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2019-07-14 21:48:13.160542: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1763] Adding visible gpu devices: 0
2019-07-14 21:48:13.160559: I tensorflow/stream_executor/platform/default/dso_loader.cc:42] Successfully opened dynamic library libcudart.so.10.0
2019-07-14 21:48:13.161120: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1181] Device interconnect StreamExecutor with strength 1 edge matrix:
2019-07-14 21:48:13.161129: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1187]      0 
2019-07-14 21:48:13.161133: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1200] 0:   N 
2019-07-14 21:48:13.161331: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:1005] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2019-07-14 21:48:13.161730: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:1005] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2019-07-14 21:48:13.162120: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1326] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 6794 MB memory) -> physical GPU (device: 0, name: GeForce RTX 2080, pci bus id: 0000:01:00.0, compute capability: 7.5)
2019-07-14 21:48:13.497639: I tensorflow/stream_executor/platform/default/dso_loader.cc:42] Successfully opened dynamic library libcudnn.so.7
2019-07-14 21:48:14.077729: E tensorflow/stream_executor/cuda/cuda_dnn.cc:329] Could not create cudnn handle: CUDNN_STATUS_INTERNAL_ERROR
2019-07-14 21:48:14.080055: E tensorflow/stream_executor/cuda/cuda_dnn.cc:329] Could not create cudnn handle: CUDNN_STATUS_INTERNAL_ERROR
Traceback (most recent call last):
  File "test.py", line 16, in <module>
    print(model.predict(test_inputs))
  File "/home/yudai/.local/share/virtualenvs/pipenv_practice-DKmRVcs4/lib/python3.7/site-packages/tensorflow/python/keras/engine/training.py", line 1078, in predict
    callbacks=callbacks)
  File "/home/yudai/.local/share/virtualenvs/pipenv_practice-DKmRVcs4/lib/python3.7/site-packages/tensorflow/python/keras/engine/training_arrays.py", line 363, in model_iteration
    batch_outs = f(ins_batch)
  File "/home/yudai/.local/share/virtualenvs/pipenv_practice-DKmRVcs4/lib/python3.7/site-packages/tensorflow/python/keras/backend.py", line 3292, in __call__
    run_metadata=self.run_metadata)
  File "/home/yudai/.local/share/virtualenvs/pipenv_practice-DKmRVcs4/lib/python3.7/site-packages/tensorflow/python/client/session.py", line 1458, in __call__
    run_metadata_ptr)
tensorflow.python.framework.errors_impl.UnknownError: 2 root error(s) found.
  (0) Unknown: Failed to get convolution algorithm. This is probably because cuDNN failed to initialize, so try looking to see if a warning log message was printed above.
     [[{{node conv2d/Conv2D}}]]
  (1) Unknown: Failed to get convolution algorithm. This is probably because cuDNN failed to initialize, so try looking to see if a warning log message was printed above.
     [[{{node conv2d/Conv2D}}]]
     [[flatten/Reshape/_7]]
0 successful operations.
0 derived errors ignored.

मैंने config.gpu_options.allow_growth = True की कोशिश की, लेकिन यह इस त्रुटि को हल नहीं करता है।

मैं चाहता हूं कि कोई मेरी मदद करे।

धन्यवाद।

RTX 2070 के साथ एक ही मुद्दा

मैंने इस से संबंधित एक दिलचस्प अवलोकन किया है, जो इस त्रुटि को ट्रैक करने में मदद कर सकता है या एक व्यवहार्य समाधान ढूंढ सकता है:
मैं भी त्रुटि मिलती है Failed to get convolution algorithm के संदर्भ में Could not create cudnn handle: CUDNN_STATUS_INTERNAL_ERROR ।
सिस्टम: एनवीडिया क्वाड्रो P2000, उबंटू 18.04, tf 1.13.1, cuda10, cudnn 7.4.2 के साथ लैपटॉप मशीन
जैसा कि उल्लेख किया गया है, मैं allow_growth का उपयोग करके कार्यक्रम को सुचारू रूप से चला सकता हूं, इसलिए इसके लिए धन्यवाद, मेरे लिए काफी अच्छा है।

दिलचस्प: मैं इस त्रुटि केवल का उपयोग करते समय मिलता है tf.layers.conv... लेकिन का उपयोग करने जा tf.keras.layers.... कार्यक्रम की अनुमति देता है बिना चलाने के लिए allow_growth , इसलिए keras कोड में कुछ में की तुलना में बेहतर काम करने लगता है tf कोड। हो सकता है कि कोई व्यक्ति इस सूचना का उपयोग करेसे के समाधान को ट्रैक करने के लिए कर सकता है।
मैं अभी के लिए tf.layers से चिपके हुए हूं, क्योंकि वे चर स्कोप के माध्यम से एक आसान वजन साझाकरण प्रदान करते हैं, जो कि केरस द्वारा दु: खद रूप से समर्थित नहीं हैं।

@ DavidS3141 यह दिलचस्प है। मेरे मामले में, केवल कनफर्मेशन लेयर tf.layers और tf.keras.layers दोनों में काम नहीं करता है ...

जब मैं pytorch का उपयोग करता हूं, तो torch.cuda.is_available सत्य है और बिना किसी परेशानी के कनवल्शन लेयर का उपयोग कर सकता है, इसलिए मेरा मानना ​​है कि इसका कारण टेंसोफ़्लो है, लेकिन मुझे नहीं पता कि क्या गलत है।

मैं @ हयाशी-युदाई से सहमत हूं: एमएक्सनेट के बारे में भी यही सच है। जब Tensorflow विफल हो जाता है तो पहचान संबंधी कॉन्फ़िगरेशन ठीक काम करता है।

वातावरण:
RTX2080
उबंटू 18.10
चालक 430.26
CUDA 10.0 (10.1 भी, जो अभी तक TF द्वारा समर्थित नहीं है)
cuDNN 7.6.1
mxnet-cu100 1.4.1
टेंसरफ्लो-जीपीयू 1.14.0

हे दोस्तों, मैं अपने CSM डेटासेट पर प्रशिक्षित करने के लिए COCO डेटासेट पर ResNet50 बैकबोन के साथ पूर्व प्रशिक्षित मॉडल से वजन का उपयोग कर रहा हूं। मुझे यह त्रुटि मिल रही है: अज्ञात: कन्वेंशन एल्गोरिथ्म प्राप्त करने में विफल।
--बैच-आकार eps - स्टेप ९ - पेप्स ४
--snapshot- पाथ स्नैपशॉट --tensorboard-dir टेंसरबोर्ड
csv डेटासेट / train.csv डेटासेट / classes.csvI ने वर्चुअल स्क्रिप्ट में कमांड लाइन में निम्न स्क्रिप्ट द्वारा समस्या को हल करने का प्रयास किया:
अजगर

आयात टेंसरफ़्लो

Tetorflow.compat.v1 इंपोर्ट कॉन्फ़िगरेशनप्रोटो से
Tetorflow.compat.v1 से इंटरएक्टिव सत्र आयात करें
config = configProto ()
config.gpu_options.allow_growth = सच
सत्र = इंटरएक्टिव सत्र (विन्यास = विन्यास)

साथ ही साथ
tf के रूप में आयात स्पर्शरेखा
config = tf.ConfigProto ()
config.gpu_options.allow_growth = सच
session = tf.Session (config = config) लेकिन इसने मेरी त्रुटि का समाधान नहीं किया।

मैं उपयोग कर रहा हूँ
उबंटू 16.0
कूडा: 10.0
टेंसरफ्लो 1.14.0

त्रुटि:
टेंसरफ़्लोफ़्थोन.फ़्रामवर्क.errors_impl.UnognError: 2 रूट त्रुटि (s) मिलीं। │ | कोई चल रही प्रक्रिया नहीं मिली |
(0) अज्ञात: कन्वेंशन एल्गोरिथ्म प्राप्त करने में विफल। यह शायद इसलिए है क्योंकि cuDNN आरंभ करने में विफल रहा, इसलिए यह देखने की कोशिश करें कि क्या चेतावनी because + ------------------------------- ---------------------------------------------- +
लॉग संदेश ऊपर मुद्रित किया गया था। │
[[{{नोड conv1 / conv}}]] conv
[[नुकसान / जोड़ / _2377]] /
(1) अज्ञात: कन्वेंशन एल्गोरिथ्म प्राप्त करने में विफल। यह शायद इसलिए है क्योंकि cuDNN आरंभ करने में विफल रहा, इसलिए यह देखने की कोशिश करें कि क्या चेतावनी u
लॉग संदेश ऊपर मुद्रित किया गया था। │
[[{{नोड conv1 / conv}}]] conv
0 सफल ऑपरेशन। │
0 व्युत्पन्न त्रुटियों को नजरअंदाज कर दिया। │
एक सक्रिय अपवाद के बिना बुलाया टर्मिनेट
निरस्त (कोर डंप)
किसी भी सहायता की सराहना की जाएगी।

यहां भी यही समस्या। Allow_growth वर्कअराउंड कार्य करता है। अन्यथा मुझे यह त्रुटि सबसे बुनियादी MNIST टेंसोफ़्लो डेटासेट पर मिलती है।

यहां RTX2060 मोबाइल।

समस्या r2.0 शाखा से संकलित टेंसरफ़्लो के साथ होती है और साथ ही टीएफ 1.4 को कोंडा (टेंसरफ़्लो-जीपीयू) के माध्यम से स्थापित किया जाता है।

@ हयाशी-युदाई

मैंने config.gpu_options.allow_growth = True की कोशिश की, लेकिन यह इस त्रुटि को हल नहीं करता है।

आपके द्वारा अपने कोड में जोड़े गए सटीक आदेश क्या थे? इसके बजाय निम्नलिखित की कोशिश करें अगर यह अलग है ...

config = tf.ConfigProto ()
config.gpu_options.allow_growth = सच
tf.keras.backend.set_session (tf.Session (config = config))

@ synapse8 आपकी टिप्पणी के लिए धन्यवाद। मैंने कोशिश की लेकिन नतीजा वही निकला।

वैसे, मैंने एनवीडिया-डॉकटर की कोशिश की और इसके अलावा अच्छी तरह से चला गया कि अजगर संस्करण 3.5 है।
https://docs.nvidia.com/deeplearning/frameworks/tensorflow-release-notes/running.html#running

एक अतिरिक्त जानकारी, अगर आपको अजगर 3.6.8 और टेंसोफ़्लो-जीपीयू 1.12.0 का उपयोग करने में कोई आपत्ति नहीं है, तो आप एनाकोंडा का उपयोग कर सकते हैं।

conda create -n <virtual env name> python=3.6.8
conda install tensorflow-gpu==1.12.0
conda install cudnn==7.3.1    # By default, cudnn7.6 is installed but it causes the error

मैंने CUDA-10.1 और CUDNN-7.6.2.4 के स्रोतों से भवन tf-2.0.0-beta1 का परीक्षण किया और त्रुटि प्रकट हुई।

आप यहाँ tf-gpu पैकेज और tf- बेस पैकेज बनाने के लिए docker चित्र पा सकते हैं:
https://github.com/edowson/docker-tensorflow

इस टिप्पणी को लिखने के समय एनाकोंडा चैनल में cudnn==7.6.2 ।

विंडोज 7, ने एक नई मशीन प्राप्त करने की कोशिश में काफी देर तक Could not create cudnn handle: CUDNN_STATUS_INTERNAL_ERROR दीवार के खिलाफ मेरे सिर को धराशायी किया।

Reinstalls, इस और अन्य धागे में अन्य चीजों के बहुत सारे इसे ठीक नहीं किया।

परीक्षण करते समय cudnn64_7.dll नहीं होने के कारण CUDNN_STATUS_INTERNAL_ERROR तुलना में एक अलग त्रुटि होगी, मैंने dll का नाम बदल दिया। त्रुटि की पुष्टि करने के बजाय CUDNN NOT INSTALLED प्रकार की त्रुटि थी, मैंने फ़ाइल नाम परिवर्तन को खोल दिया।

जादुई रूप से, सब कुछ काम करना शुरू कर दिया।

कोई विचार क्यों या कैसे नहीं, लेकिन यह करता है। उम्मीद है कि यह किसी और की मदद करता है। यदि नहीं, तो यह कोशिश करने के लिए केवल कुछ सेकंड लेता है।

मैंने पाया कि यह समस्या मेरे द्वारा गलत तरीके से tf.Session को दो कॉल करने के कारण हुई थी

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

# several lines of code later...

sess = tf.Session(config=config)

शायद ज्यादातर लोगों के लिए मूल कारण नहीं है, लेकिन यह देखने लायक हो सकता है।

बस "allow_growth = True" साझा करने के लिए नीचे मेरे सिस्टम के लिए समस्या हल करता है
rtx 2080ti, ubuntu18.04, cuda9.0, cudnn7, tf1.9

config = tf.ConfigProto ()
config.gpu_options.allow_growth = सच
सत्र = tf.Session (विन्यास = विन्यास)

यह cudnn हैंडल बनाने के लिए GPU संसाधनों को लोड करने के लिए उपलब्ध मेमोरी अंश के साथ करना है, जिसे per_process_gpu_memory_fraction रूप में भी जाना जाता है।
इस मेमोरी अंश को अपने आप कम करने से त्रुटि हल हो जाएगी।

> sess_config = tf.ConfigProto(gpu_options =
> tf.GPUOptions(per_process_gpu_memory_fraction=0.7),
> allow_soft_placement = True)
> 
> with tf.Session(config=sess_config) as sess:
>      sess.run([whatever])

अपनी स्मृति में फिट होने वाले छोटे अंश का उपयोग करें। (कोड में, मैं 0.7 का उपयोग करता हूं, आप 0.3 या उससे भी छोटे से शुरू कर सकते हैं, तब तक बढ़ा सकते हैं जब तक कि आपको एक ही त्रुटि न मिले, यह आपकी सीमा है।)
इसे अपने tf.Session() या tf.train.MonitoredTrainingSession() या पर्यवेक्षक के sv.managed_session() के लिए पास करें।

यह आपके GPU को आपके TensorFlow कोड के लिए cudnn हैंडल बनाने की अनुमति देता है।

जैसा कि यहाँ बताया गया config.gpu_options.allow_growth = True सेट करने के लिए TF 2.0 में नया दृष्टिकोण है:

gpus = tf.config.experimental.list_physical_devices('GPU')
if gpus:
  # Currently, memory growth needs to be the same across GPUs
  try:
    for gpu in gpus:
      tf.config.experimental.set_memory_growth(gpu, True)
  except RuntimeError as e:
    print(e)

इस कोड स्निपेट और TF 2.0 RC1 के साथ, त्रुटि अब प्रकट नहीं होती है।
हालांकि, 20XX एनवीडिया जीपीयू वाले लोगों की संख्या के कारण, मुझे लगता है कि टीएफ 2.0 के अंतिम संस्करण के रिलीज़ होने से पहले इस समस्या को मूल रूप से संबोधित करना एक अच्छा विचार होगा।

मैं TF1.4 पर 1080Ti और TitanX के साथ एक ही मुद्दा था और @ va-andrew और @oscarlinux के सुझावों ने दिन बचा लिया! जो मुझे पहली बार में याद दिलाता है कि मैंने पाइटोरच में क्यों स्विच किया और कभी वापस नहीं आया। दुर्भाग्य से वहाँ अभी भी pf का उपयोग कर ppl हैं .... इसलिए मुझे अभी भी इस दर्द से गुजरना पड़ता है जब भी मैं उनके कोडबेस का उपयोग करता हूं ... शायद यह ONNX के साथ थोड़ा खेलने का समय है।

किसी और के लिए टेंसरफ़्लो 2.0 में अपग्रेड करने के बाद इसे खोजने के लिए, एपीआई और कोड थोड़ा अलग हैं।

उबंटू १ 18
टेंसरफ्लो 2.0
टेंसरफ्लो-जीपीयू २.०
GeForce RTX 2070

इस प्रणाली के लिए अद्यतन कोड।

import tensorflow as tf
config = tf.compat.v1.ConfigProto()
config.gpu_options.allow_growth = True
session = tf.compat.v1.Session(config=config)

इस समाधान ने मेरे लिए काम किया। (TF-GPU 2.0, Windows 10, GeForce RTX 2070)

physical_devices = tf.config.experimental.list_physical_devices('GPU')
assert len(physical_devices) > 0, "Not enough GPU hardware devices available"
tf.config.experimental.set_memory_growth(physical_devices[0], True)

अतिरिक्त डेटापॉइंट जोड़ें:
rtx 2080ti, ubuntu18.04, cuda10.0, cudnn7
मेरे मामले में यह tf1.14 और 1.15rc3 के साथ काम नहीं करता है

@ w4nderlust , 1.14 और 1.15 के लिए आप सत्र विन्यास विकल्प config.gpu_options.allow_growth = True सेट करना जारी रखना चाहेंगे। क्या आप जो रिपोर्ट कर रहे हैं वह काम नहीं करता है, या सिर्फ tf.config.experimental तंत्र है?

@ w4nderlust , 1.14 और 1.15 के लिए आप सत्र विन्यास विकल्प config.gpu_options.allow_growth = True सेट करना जारी रखना चाहेंगे। क्या आप जो रिपोर्ट कर रहे हैं वह काम नहीं करता है, या सिर्फ tf.config.experimental तंत्र है?

क्षमा करें अधिक सटीक होना चाहिए था, मैं रिपोर्ट कर रहा हूं कि config.gpu_options.allow_growth = True बिना यह अभी भी 1.14 और 1.15rc3 दोनों के साथ मेरे कॉन्फ़िगरेशन में काम नहीं करता है।

मुझे लगता है कि मुझे config.gpu_options.allow_growth = True से बेहतर वर्कअराउंड मिला।

मेरे सेटअप के लिए (_RTX 2070_, docker की छवि _tensorflow: 1.15.0-gpu-py3_), नीचे दिखाए गए विन्यास को सेट करने से _CUDNN_STATUS_INTERNAL_ERROR_ से बचा जाता है जबकि अभी भी संपूर्ण GPU मेमोरी आवंटित नहीं की गई है ।
यह बड़े मॉडलों के लिए बहुत उपयोगी है जो allow_growth मोड में मेमोरी में फिट नहीं होंगे, लेकिन सिर्फ तब फिट होते हैं जब पूरी मेमोरी आवंटित की जाती है।

RTX पर संपूर्ण मेमोरी आवंटित करने के लिए:
config.gpu_options.per_process_gpu_memory_fraction = 1.0

RTX पर संपूर्ण मेमोरी आवंटित करने के लिए:
config.gpu_options.per_process_gpu_memory_fraction = 1.0

@PoloShock
मैंने TF 2.0 के साथ यह कोशिश की और यह काम नहीं करता है।
Ubuntu18.04, RTX 2080, CUDA10, cudnn 7.6।

TF 2.0 के लिए GPU मेमोरी के उपयोग को सीमित करने के लिए एपीआई बदल गया है।

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

tf.config.experimental.set_virtual_device_configuration(gpus[0], [tf.config.experimental.VirtualDeviceConfiguration(memory_limit=1024)]

@nluehr क्या आप समझते हैं कि यह मुद्दा केवल RTX पर क्यों

मेरे लिए सीधे यह डीबग करना मुश्किल है क्योंकि मेरे पास आरटीएक्स जीपीयू तक पहुंच नहीं है।

@sanjoy मैं एकीकृत gpu पर प्रदर्शन चला रहा हूं। TensorFlow चलाते समय मेरे एकल RTX gpu पर कोई अन्य ऐप नहीं।

मैंने टेंसरफ़्लो 2.0 के लिए इसका उपयोग करने की कोशिश की:

    config = tf.compat.v1.ConfigProto()
    config.gpu_options.allow_growth = True
    session = tf.compat.v1.Session(config=config)

यह मेरे rtx2080 पर cudnn त्रुटि को ठीक करता है, लेकिन प्रशिक्षण मेरे लैपटॉप पर मेरे 1050Ti जितना तेज़ है!
सीएनएन प्रशिक्षण देते समय:

Tue Nov 12 19:22:35 2019       
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 440.26       Driver Version: 440.26       CUDA Version: 10.2     |
|-------------------------------+----------------------+----------------------+
| 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 RTX 2080    Off  | 00000000:2D:00.0 Off |                  N/A |
|  0%   37C    P2    75W / 265W |   2904MiB /  7979MiB |     27%      Default |
+-------------------------------+----------------------+----------------------+

+-----------------------------------------------------------------------------+
| Processes:                                                       GPU Memory |
|  GPU       PID   Type   Process name                             Usage      |
|=============================================================================|
|    0      1026      G   /usr/lib/Xorg                                200MiB |
|    0      6420      G   cinnamon                                      43MiB |
|    0     21073      C   /home/clementpoiret/anaconda3/bin/python    2647MiB |
+-----------------------------------------------------------------------------+

जोड़ा जा रहा है

gpus = tf.config.experimental.list_physical_devices('GPU')
tf.config.experimental.set_virtual_device_configuration(gpus[0], [tf.config.experimental.VirtualDeviceConfiguration(memory_limit=7000)]

इस समस्या को हल नहीं किया, बिना allow_growth मुझे cudnn त्रुटि मिल रही है, और वैसे भी मेरा RTX केवल 3Gb या मेमोरी जैसी किसी चीज़ का उपयोग कर रहा है।

कोई उपाय ?

मैंने कोशिश की

    gpus = tf.config.experimental.list_physical_devices('GPU')
    tf.config.experimental.set_memory_growth(gpus[0], True)
    tf.config.experimental.set_virtual_device_configuration(
        gpus[0],
        [tf.config.experimental.VirtualDeviceConfiguration(memory_limit=7900)])

लेकिन cudnn अभी भी एक त्रुटि फेंक रहा है

मुझे यह त्रुटि भी काम करने में मिल रही है 1.15.0-py3-gpu Docker छवि (Ubuntu 18.04) दो टाइटन V GPUs (@sanjoy) के साथ - आरटीएक्स नहीं। हालाँकि, यह त्रुटि केवल मेरे GPU0 पर मेरे लिए होती है, जिसमें GPU0 मेमोरी का उपयोग करते हुए Xorg और सूक्ति-शैल है जबकि GPU1 में केवल GPU मेम का उपयोग करके अजगर है और यह त्रुटि नहीं फेंकता है। त्रुटि भी दुर्भाग्य से रुक-रुक कर है - कभी-कभी मैं डॉकटर कंटेनर को निकालने में सक्षम हो जाएगा, इसे उसी सेटिंग्स और समान कोड के साथ फिर से बनाऊंगा, फिर त्रुटि दूर हो जाएगी। या नहीं।

मैं इसके साथ केरस बैकएंड इंटरफेस का उपयोग करके इसे ठीक करने में सक्षम था:

import tensorflow as tf

config = tf.ConfigProto()
config.gpu_options.allow_growth = True
allow_growth_session = tf.Session(config=config)
tf.keras.backend.set_session(allow_growth_session)

दोनों GPU पर मेरे nvidia-smi का अनुसरण किया जा रहा है

+-----------------------------------------------------------------------------+
| NVIDIA-SMI 440.26       Driver Version: 440.26       CUDA Version: 10.2     |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|===============================+======================+======================|
|   0  TITAN V             Off  | 00000000:01:00.0  On |                  N/A |
| 46%   63C    P2    51W / 250W |   7936MiB / 12065MiB |     31%      Default |
+-------------------------------+----------------------+----------------------+
|   1  TITAN V             Off  | 00000000:02:00.0 Off |                  N/A |
| 52%   70C    P2   131W / 250W |  12014MiB / 12066MiB |     60%      Default |
+-------------------------------+----------------------+----------------------+

+-----------------------------------------------------------------------------+
| Processes:                                                       GPU Memory |
|  GPU       PID   Type   Process name                             Usage      |
|=============================================================================|
|    0      1564      G   /usr/lib/xorg/Xorg                            56MiB |
|    0      1607      G   /usr/bin/gnome-shell                          58MiB |
|    0      2428      G   /usr/lib/xorg/Xorg                           442MiB |
|    0      2574      G   /usr/bin/gnome-shell                         289MiB |
|    0      3292      G   ...p/pycharm-professional/167/jbr/bin/java    12MiB |
|    0      6794      G   anki                                          60MiB |
|    0     10336      G   /usr/lib/firefox/firefox                       6MiB |
|    0     16986      C   python                                      6981MiB |
|    1      4057      C   python                                     12001MiB |
+-----------------------------------------------------------------------------+

मैं TF 2.0 conda के माध्यम से स्थापित @clementpoiret रूप में एक ही समस्या आ रही है। allow_growth ध्वज का उपयोग करने से समस्या गायब हो जाती है, लेकिन यह भी प्रशिक्षण को बहुत धीमा कर देता है, जो कि टीएफ 1.x पर मेरे पास था उससे भी धीमा ... एगर पहले उह?

@clementpoiret और @EKami, यह अपने प्रशिक्षण में तेजी लाने पड़ता कि आप की जगह config.gpu_options.allow_growth = True के साथ config.gpu_options.per_process_gpu_memory_fraction = 0.8 ? आप यह देखने के लिए प्रयोग कर सकते हैं कि कौन सा अंश आपके gpu का सबसे अधिक उपयोग करता है।

@ synapse8 मुझे ts.config.experimental के साथ ऐसा करने के लिए किसी भी तरह से टेंसरफ़्लो 2.0 के दस्तावेज़ में कुछ समान नहीं दिखता है?

संपादित करें: मैं इस तरह से मेमोरी सेट करने का प्रयास करने जा रहा हूं, यह देखने के लिए कि क्या यह समस्या हल हो रही है:

import subprocess
import tensorflow as tf


def get_gpus_memory():
    """Get the max gpu memory.

    Returns
    -------
    usage: list
        Returns a list of total memory for each gpus.
    """
    result = subprocess.check_output([
        "nvidia-smi", "--query-gpu=memory.total",
        "--format=csv,nounits,noheader"
    ]).decode("utf-8")

    gpus_memory = [int(x) for x in result.strip().split("\n")]
    return gpus_memory


def setup_gpus(allow_growth=True, memory_fraction=.9):
    """Setup GPUs.

    Parameters:
    allow_growth (Boolean)
    memory_fraction (Float): Set maximum memory usage, with 1 using
        maximum memory
    """
    gpus = tf.config.experimental.list_physical_devices("GPU")
    if gpus:
        try:
            # Currently, memory growth needs to be the same across GPUs
            for i, gpu in enumerate(gpus):
                memory = get_gpus_memory()[i]

                tf.config.experimental.set_memory_growth(gpu, allow_growth)

                # Setting memory limit to max*fraction
                tf.config.experimental.set_virtual_device_configuration(
                    gpu, [
                        tf.config.experimental.VirtualDeviceConfiguration(
                            memory_limit=memory * memory_fraction)
                    ])

                logical_gpus = tf.config.experimental.list_logical_devices(
                    "GPU")
                print(len(gpus), "Physical GPUs,", len(logical_gpus),
                      "Logical GPUs")
        except RuntimeError as e:
            # Memory growth must be set before GPUs have been initialized
            print(e)

इस तरह हम आसानी से setup_gpus(True, .9) कॉल कर सकते हैं

@ क्लेमेंटपोइरेर्ट : कृपया ध्यान दें कि tf.config.experimental.set_memory_growth कॉल अनावश्यक है क्योंकि tf.config.experimental.set_virtual_device_configuration उस झंडे को ओवरराइड करता है क्योंकि यह GPU मेमोरी को स्लाइस करता है और आवंटित मेमोरी को पूर्व-आवंटित करता है।

यह समस्या RTX तक सीमित नहीं है। या टीएफ 2.0।

जोड़ना:
_from tanorflow.compat.v1 इंपोर्ट कॉन्फ़िगरेशनप्रो
Tetorflow.compat.v1 से इंटरएक्टिव सत्र आयात करें
config = configProto ()
config.gpu_options.allow_growth = सच
सत्र = इंटरएक्टिव सत्र (config = config) _

"Cudnn हैंडल नहीं बना सका: CUDNN_STATUS_INTERNAL_ERROR" पर्यावरण के साथ समस्या निम्नानुसार है:

nvidia-smi | NVIDIA-SMI 430.50 Driver Version: 430.50 CUDA Version: 10.1 | | 0 GeForce GT 1030 | 49% 67C P0 N/A / 30W | 1957MiB / 2000MiB | 94%

python -c 'import tensorflow as tf; print(tf.__version__)' 1.14.0
यह NVIDIA ड्राइवरों के साथ एक अधिकतम सन्निहित ब्लॉक आवंटन मुद्दा हो सकता है? जहाँ मेमोरी की कुल मात्रा लेकिन छोटे ब्लॉकों में आवंटित करना ठीक है?

नमस्ते,

मैं इसे अपनी मशीन पर पुन: पेश नहीं कर सकता, इसलिए मुझे इसकी मदद करने के लिए कुछ रूट की आवश्यकता होगी। क्या हमारे पास कोई ऐसा व्यक्ति है जो समस्या को पुन: उत्पन्न कर सकता है और कुछ हाथों से डिबगिंग करने को तैयार है?

एक शुरुआती बिंदु के रूप में मैं यह समझना चाहूंगा कि MinSystemMemory cuDNN के लिए पर्याप्त मेमोरी संरक्षित नहीं करता है। यदि कोई ऐसा सेटअप वाला व्यक्ति जो इस समस्या को पुन: उत्पन्न करता है, तो MinSystemMemory द्वारा लौटाए गए स्मृति की मात्रा का पता लगाने के लिए कुछ लॉगिंग (स्थानीय पैच के रूप में) जोड़ सकता है जो बहुत अच्छा होगा। और क्या जादू 0.05 संख्या MinSystemMemory स्थिति को बढ़ाने में मदद करता है?

@sanjoy मेरे पास एक संस्करण है जो इस समस्या को प्रदर्शित करता है। मैं MinSystemMemory तक पहुँचने या "मैजिक 0.05 नंबर सेट करने" के बारे में कैसे जाऊँगा? मैं सबसे अधिक भाग के लिए cuda 9.1 का उपयोग करने के लिए वापस आ गया हूं, लेकिन मुझे कुछ चीजों की कोशिश करने में कोई आपत्ति नहीं है।

@odinsbane आपको स्रोत से TensorFlow का निर्माण करना होगा जो मैं नीचे सुझाता हूं।

पहला कदम LOG(INFO) या std::cerr लाइनों को MinSystemMemory available_memory प्रिंट करना है और MinSystemMemory से वापसी मूल्य जोड़ना है। क्या available_memory nvidia-smi प्रिंट से सहमत हैं? हम सिस्टम के लिए कितनी स्मृति छोड़ रहे हैं?

दूसरी बात, क्या 0.05 मैजिक नंबर बढ़ाने के लिए, कहते हैं, 0.07 बिल्कुल भी मदद नहीं करता है?

यह एक काम करता है! आप लोगों को धन्यवाद!

from keras.backend.tensorflow_backend import set_session
$ import tensorflow as tf
$ config = tf.ConfigProto()
$ config.gpu_options.allow_growth = True
$ config.log_device_placement = True
$ sess = tf.Session(config=config)
$ set_session(sess)

हम अपने RTX 2070 (Ubuntu 18.04, TF2) पर एक समान समस्या का सामना कर रहे हैं। हमने CUDA 10.0 और libcudnn7.xxx संस्करणों के विभिन्न संयोजनों की कोशिश की, लेकिन त्रुटि फिर से दिखाई देती है।
एक अन्य मशीन पर हमारे पास GTX 1080ti है और यह बिना किसी समस्या के चलता है।
दोनों मामलों में एनवीडिया-चालक 430.50 है।

यह tf.keras.utils.plot_model कारण नहीं है, मैं इसे हटा देता हूं और यह त्रुटि अभी भी प्रकट होती है, लेकिन कम बार।
अपडेट: मुझे यह केवल तभी मिलता है जब मैं tf.keras.utils.plot_model उपयोग करता हूं। मैं कोशिश करता रहूँगा।

============

मैं Ubuntu 18.04.3 LTS, tf 1.15, cuda 10.0 पर RTX 2080 Ti के साथ एक समान मुद्दा है।

मेरे मामले में यह अजीब है कि यह केवल कभी-कभार ही होता है, और एक बार ऐसा हो जाए, तो यह मिनटों तक चलेगा और फिर बस खुद ही गायब हो जाएगा ।

मैंने उपरोक्त सभी समाधानों की कोशिश की और कोई भी इसे तुरंत ठीक नहीं कर सकता है। मैंने कुछ भी नहीं करने की कोशिश की और बस इंतजार करो, यह अंत में गायब हो जाएगा।

मैंने भी क्या कोशिश की और ऊपर उल्लेख नहीं किया गया है:

1. ~/.nv निर्देशिका निकालें
2. बस रिबूट

FYI करें, त्रुटि लॉग

2019-12-21 14:47:30.785233: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcublas.so.10.0
2019-12-21 14:47:30.959825: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcudnn.so.7
2019-12-21 14:47:31.722238: E tensorflow/stream_executor/cuda/cuda_dnn.cc:329] Could not create cudnn handle: CUDNN_STATUS_INTERNAL_ERROR
2019-12-21 14:47:31.749524: E tensorflow/stream_executor/cuda/cuda_dnn.cc:329] Could not create cudnn handle: CUDNN_STATUS_INTERNAL_ERROR
Traceback (most recent call last):
  File "train_cifar.py", line 204, in <module>
    main()
  File "train_cifar.py", line 133, in main
    validation_data=(x_test, output_test), callbacks=callbacks, verbose=0)
  File "/home/xxx/anaconda3/envs/tf-1-gpu/lib/python3.7/site-packages/tensorflow_core/python/keras/engine/training.py", line 727, in fit
    use_multiprocessing=use_multiprocessing)
  File "/home/xxx/anaconda3/envs/tf-1-gpu/lib/python3.7/site-packages/tensorflow_core/python/keras/engine/training_generator.py", line 603, in fit
    steps_name='steps_per_epoch')
  File "/home/xxx/anaconda3/envs/tf-1-gpu/lib/python3.7/site-packages/tensorflow_core/python/keras/engine/training_generator.py", line 265, in model_iteration
    batch_outs = batch_function(*batch_data)
  File "/home/xxx/anaconda3/envs/tf-1-gpu/lib/python3.7/site-packages/tensorflow_core/python/keras/engine/training.py", line 1017, in train_on_batch
    outputs = self.train_function(ins)  # pylint: disable=not-callable
  File "/home/xxx/anaconda3/envs/tf-1-gpu/lib/python3.7/site-packages/tensorflow_core/python/keras/backend.py", line 3476, in __call__
    run_metadata=self.run_metadata)
  File "/home/xxx/anaconda3/envs/tf-1-gpu/lib/python3.7/site-packages/tensorflow_core/python/client/session.py", line 1472, in __call__
    run_metadata_ptr)
tensorflow.python.framework.errors_impl.UnknownError: 2 root error(s) found.
  (0) Unknown: Failed to get convolution algorithm. This is probably because cuDNN failed to initialize, so try looking to see if a warning log message was printed above.
     [[{{node stem_layer/conv2d/Conv2D}}]]
     [[metrics/classifier_acc/Identity/_1749]]
  (1) Unknown: Failed to get convolution algorithm. This is probably because cuDNN failed to initialize, so try looking to see if a warning log message was printed above.
     [[{{node stem_layer/conv2d/Conv2D}}]]
0 successful operations.
0 derived errors ignored.

हम प्रासंगिक मुद्दों का सामना कर रहे हैं

सिस्टम विनिर्देशों

• उबंटू 18.04.3 एलटीएस
• RTX 2070
• अजगर 3.7.1
• tf-gpu 2.0.0
• V10.0.130 CUDA
• libcudn7 7.6.2

त्रुटि तब शुरू होती है जब मैं LSTM, GRU, RNN आदि का उपयोग करने का प्रयास करता हूं।

वास्तविक त्रुटि

2019-12-23 16:09:00.912238: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcudnn.so.7 2019-12-23 16:09:01.408990: E tensorflow/stream_executor/cuda/cuda_dnn.cc:329] Could not create cudnn handle: CUDNN_STATUS_INTERNAL_ERROR 2019-12-23 16:09:01.409043: W tensorflow/core/framework/op_kernel.cc:1622] OP_REQUIRES failed at cudnn_rnn_ops.cc:1491 : Unknown: Fail to find the dnn implementation.

File "/home/alex/anaconda3/envs/tf/lib/python3.7/site-packages/tensorflow_core/python/keras/layers/recurrent_v2.py", line 961, in call **cudnn_lstm_kwargs) File "/home/alex/anaconda3/envs/tf/lib/python3.7/site-packages/tensorflow_core/python/keras/layers/recurrent_v2.py", line 1174, in cudnn_lstm rnn_mode='lstm') File "/home/alex/anaconda3/envs/tf/lib/python3.7/site-packages/tensorflow_core/python/ops/gen_cudnn_rnn_ops.py", line 109, in cudnn_rnn ctx=_ctx) File "/home/alex/anaconda3/envs/tf/lib/python3.7/site-packages/tensorflow_core/python/ops/gen_cudnn_rnn_ops.py", line 198, in cudnn_rnn_eager_fallback attrs=_attrs, ctx=_ctx, name=name) File "/home/alex/anaconda3/envs/tf/lib/python3.7/site-packages/tensorflow_core/python/eager/execute.py", line 67, in quick_execute six.raise_from(core._status_to_exception(e.code, message), None) File "<string>", line 3, in raise_from tensorflow.python.framework.errors_impl.UnknownError: Fail to find the dnn implementation. [Op:CudnnRNN]

स्पष्ट समस्या

जैसा कि लगता है कि मेरी सारी मेमोरी बहुत तेजी से खत्म हो गई है। समस्याएँ केवल gpu मोड में आती हैं, समान कोड cpu के साथ ठीक काम करता है

परीक्षणों

• स्मृति वृद्धि की अनुमति दें
• सीमित मेमोरी के साथ वर्चुअल डिवाइस बनाएं

दोनों एक ही त्रुटि का उत्पादन करने की कोशिश करते हैं।

कोई विचार?

मैं इस मुद्दे पर प्रगति नहीं कर सकता क्योंकि मैं इसे पुन: पेश नहीं कर सकता। यदि आप अपनी मशीन पर मज़बूती से इसे पुन: पेश करने में सक्षम हैं, तो आप मदद कर सकते हैं; यहाँ कैसे है: https://github.com/tensorflow/tensorflow/issues/24496#issuecomment -560963770, https://github.com/tensorflow/tensorflow/issues/24496#issuecomment -561366750

मैं इस मुद्दे पर प्रगति नहीं कर सकता क्योंकि मैं इसे पुन: पेश नहीं कर सकता। यदि आप अपनी मशीन पर मज़बूती से इसे पुन: पेश करने में सक्षम हैं, तो आप मदद कर सकते हैं; यहाँ कैसे है: # 24496 (टिप्पणी) , # 24496 (टिप्पणी)

हाय @sanjoy , मैं मदद करने के लिए बहुत तैयार हूँ, लेकिन दुर्भाग्य से मैं स्रोत से tf नहीं बना सकता क्योंकि मैं अपने प्रयोग करने के लिए अपने विश्वविद्यालय के गुणों का उपयोग कर रहा हूँ और मेरा निजी लैपटॉप GPU से सुसज्जित नहीं है। क्या हमें जिस लॉग की आवश्यकता है उसे प्राप्त करने के लिए कोई अन्य तरीका है?

मुझे स्टैक ओवरफ्लो पर निम्न कोड मिला, क्या यह मदद कर सकता है?

from tensorflow.contrib.memory_stats.python.ops.memory_stats_ops import BytesInUse
with tf.device('/device:GPU:0'):  # Replace with device you are interested in
  bytes_in_use = BytesInUse()
with tf.Session() as sess:
  print(sess.run(bytes_in_use))

क्या हमें जिस लॉग की आवश्यकता है उसे प्राप्त करने के लिए कोई अन्य तरीका है?

मैं इस जानकारी को प्राप्त करने के लिए एक VLOG कथन में जांच करूंगा। एक बार जब यह हो जाता है, तो क्या आप इसे tf-nightly (कुछ अतिरिक्त झंडे के साथ, पुन: उत्पन्न कर पाएंगे और मैं आपको बता दूंगा कि वास्तव में कौन से हैं)?

निश्चित रूप से, मैं उस कंप्यूटर पर एक पैकेज स्थापित कर सकता हूं यदि यह pip या conda और मैं एक आभासी वातावरण का उपयोग करता हूं। मैं त्रुटि को पुन: उत्पन्न करने का प्रयास करूंगा।

निश्चित रूप से, मैं उस कंप्यूटर पर एक पैकेज स्थापित कर सकता हूं यदि यह pip या conda और मैं एक आभासी वातावरण का उपयोग करता हूं। मैं त्रुटि को पुन: उत्पन्न करने का प्रयास करूंगा।

आप स्थापित कृपया tf-रात (इतना है कि यह ऊपर उठाता प्रतिबद्ध है कि प्रवेश कहते हैं) और पर्यावरण चर के साथ चलाने के TF_CPP_VMODULE करने के लिए सेट gpu_device=5 ? कि दो लाइनों की तरह प्रिंट करना चाहिए

2019-12-26 12:07:37.196206: I tensorflow/core/common_runtime/gpu/gpu_device.cc:837] available_memory = 12319588352                                             
2019-12-26 12:07:37.196221: I tensorflow/core/common_runtime/gpu/gpu_device.cc:838] min_system_memory = 615979417                                              

क्या आप कृपया इन नंबरों की रिपोर्ट यहां कर सकते हैं?

क्षमा करें, मेरा वर्तमान कोड tf 2.0 के साथ संगत नहीं है (मैं 1.15 का उपयोग करता हूं), मैं इसे अपडेट करने की कोशिश कर रहा हूं। कृपया मुझे कुछ समय दें।

यह समस्या मेरे RTX2080 से संबंधित है, मेरे पास एक डेस्कटॉप GTX1080 है, सब कुछ ठीक लगता है, तो मैं अपने RTX2080 नोटबुक के लिए कोंडा क्लोन का उपयोग करता हूं, मैं टेंसरफ़्लो 2.0.0-gpu का उपयोग करता हूं। एक बार एप्लिकेशन कोड के उपयोग के बाद Conv2d, LSTM, GRU तब यह परेशानी आती है।
इससे पहले कि मैं इस समस्या को हल करने के लिए निम्नलिखित कोड का उपयोग करूं:
gpus = tf.config.experimental.list_physical_devices ('GPU')
अगर gpus:
प्रयत्न:

वर्तमान में, मेमोरी ग्रोथ जीपीयू में समान होनी चाहिए

    for gpu in gpus:
        tf.config.experimental.set_memory_growth(gpu, True)
        logical_gpus = tf.config.experimental.list_logical_devices('GPU')
        print(len(gpus), "Physical GPUs,", len(logical_gpus), "Logical GPUs")
except RuntimeError as e:

जीपीयू को इनिशियलाइज़ करने से पहले मेमोरी ग्रोथ सेट करना होगा

    print(e)

लेकिन कई दिनों पहले से, उपरोक्त विधि किसी भी अधिक काम नहीं करती है

मुझे gtx 960m के साथ भी यही समस्या है

हाय @sanjoy , मुझे अभी यह आउटपुट मिला है:

2019-12-30 17:38:23.824323: I tensorflow/core/common_runtime/gpu/gpu_device.cc:837] available_memory = 10840309760
2019-12-30 17:38:23.824328: I tensorflow/core/common_runtime/gpu/gpu_device.cc:838] min_system_memory = 542015488

हाय @sanjoy , मुझे अभी यह आउटपुट मिला है:

2019-12-30 17:38:23.824323: I tensorflow/core/common_runtime/gpu/gpu_device.cc:837] available_memory = 10840309760
2019-12-30 17:38:23.824328: I tensorflow/core/common_runtime/gpu/gpu_device.cc:838] min_system_memory = 542015488

धन्यवाद!

दुर्भाग्य से यह उतना नहीं था जितना मैंने सोचा था। अगर मैं क्लैंप MinSystemMemory के लिए एक स्थानीय निर्माण पर 542015488 (यानी min_system_memory = std::min(min_system_memory, 542015488ll) ) resnet (उदाहरण के लिए) ठीक काम करने लगता है, और मैं cuDNN से किसी भी त्रुटि नहीं मिलता है ।

@sanjoy मैं (ज्यादातर लगातार) मेरे अंत में इस मुद्दे को पुन: पेश करने में सक्षम हूं।

नवीनतम रात्रि के प्रासंगिक संदेश:

स्मृति वृद्धि के साथ स्पष्ट रूप से अनुमति दी गई है

2019-12-30 22:51:06.846774: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library cudart64_101.dll
WARNING:tensorflow:Falling back to tensorflow client, its recommended to install the cloud tpu client directly with pip install cloud-tpu-client .
2019-12-30 22:51:08.851660: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library nvcuda.dll
2019-12-30 22:51:08.877811: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1558] Found device 0 with properties: 
pciBusID: 0000:08:00.0 name: GeForce GTX 1070 computeCapability: 6.1
coreClock: 1.7715GHz coreCount: 15 deviceMemorySize: 8.00GiB deviceMemoryBandwidth: 238.66GiB/s
2019-12-30 22:51:08.887672: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library cudart64_101.dll
2019-12-30 22:51:08.895277: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library cublas64_10.dll
2019-12-30 22:51:08.906016: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library cufft64_10.dll
2019-12-30 22:51:08.913767: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library curand64_10.dll
2019-12-30 22:51:08.921329: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library cusolver64_10.dll
2019-12-30 22:51:08.930208: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library cusparse64_10.dll
2019-12-30 22:51:08.941818: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library cudnn64_7.dll
2019-12-30 22:51:08.945713: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1700] Adding visible gpu devices: 0
TF GPU device: PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')



CUDA_PATH=C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.1
Tensorflow Version: 2.1.0-dev20191230
Tensorflow_addons Version: 0.7.0-dev



Preparing data
Loading dataset
100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 80/80 [00:03<00:00, 21.61it/s] 
100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 68/68 [00:00<00:00, 447.32it/s] 
Performing NLP
100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 80/80 [00:00<00:00, 13332.71it/s] 
100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 68/68 [00:00<?, ?it/s] 
Transforming dataset
Generating primitives and constructing vocabulary
100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 80/80 [00:00<00:00, 139.11it/s] 
100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 68/68 [00:00<00:00, 4249.86it/s] 
Encoding primitives
100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 16654/16654 [00:00<00:00, 33640.74it/s]
100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 805/805 [00:00<00:00, 33538.43it/s] 
2019-12-30 22:51:22.970554: I tensorflow/core/platform/cpu_feature_guard.cc:142] Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX2
2019-12-30 22:51:22.977228: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1558] Found device 0 with properties: 
pciBusID: 0000:08:00.0 name: GeForce GTX 1070 computeCapability: 6.1
coreClock: 1.7715GHz coreCount: 15 deviceMemorySize: 8.00GiB deviceMemoryBandwidth: 238.66GiB/s
2019-12-30 22:51:22.983571: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library cudart64_101.dll
2019-12-30 22:51:22.986832: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library cublas64_10.dll
2019-12-30 22:51:22.990667: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library cufft64_10.dll
2019-12-30 22:51:22.993801: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library curand64_10.dll
2019-12-30 22:51:22.996967: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library cusolver64_10.dll
2019-12-30 22:51:23.002629: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library cusparse64_10.dll
2019-12-30 22:51:23.006072: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library cudnn64_7.dll
2019-12-30 22:51:23.010482: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1700] Adding visible gpu devices: 0
2019-12-30 22:51:23.557556: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1087] TensorFlow compiled with CUDA 10.1 and cuDNN 7.6.5
2019-12-30 22:51:23.560870: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1099] Device interconnect StreamExecutor with strength 1 edge matrix:
2019-12-30 22:51:23.564144: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1105]      0 
2019-12-30 22:51:23.569159: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1118] 0:   N
2019-12-30 22:51:23.571310: I tensorflow/core/common_runtime/gpu/gpu_device.cc:837] available_memory = 7038160076
2019-12-30 22:51:23.573861: I tensorflow/core/common_runtime/gpu/gpu_device.cc:838] min_system_memory = 351908003
2019-12-30 22:51:23.576728: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1370] GPUDevice PlatformGpuId 0 TfGpuId 0 on bus 1 numa: 0 pci: 0000:08:00.0 DeviceLocality: bus_id: 1
links {
}

2019-12-30 22:51:23.583814: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1244] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 6376 MB memory) -> physical GPU (device: 0, name: GeForce GTX 1070, pci bus id: 0000:08:00.0, compute capability: 6.1)
2019-12-30 22:51:23.590034: I tensorflow/core/common_runtime/gpu/gpu_device.cc:249] Created stream[0] = 000002093BAB9860
2019-12-30 22:51:23.594885: I tensorflow/core/common_runtime/gpu/gpu_device.cc:268] Created host_to_device_stream[0] = 000002093BAB9360
2019-12-30 22:51:23.597951: I tensorflow/core/common_runtime/gpu/gpu_device.cc:273] Created device_to_host_stream[0] = 000002093BABA960
2019-12-30 22:51:23.600920: I tensorflow/core/common_runtime/gpu/gpu_device.cc:289] Created device_to_device_stream[0] = 000002093BAB8EE0

GPU डिवाइस के कॉन्फ़िगरेशन में कोई बदलाव किए बिना

2019-12-30 22:54:47.762913: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library cudart64_101.dll
WARNING:tensorflow:Falling back to tensorflow client, its recommended to install the cloud tpu client directly with pip install cloud-tpu-client .
2019-12-30 22:54:50.073199: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library nvcuda.dll
2019-12-30 22:54:50.100339: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1558] Found device 0 with properties:
pciBusID: 0000:08:00.0 name: GeForce GTX 1070 computeCapability: 6.1
coreClock: 1.7715GHz coreCount: 15 deviceMemorySize: 8.00GiB deviceMemoryBandwidth: 238.66GiB/s
2019-12-30 22:54:50.105836: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library cudart64_101.dll
2019-12-30 22:54:50.115940: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library cublas64_10.dll
2019-12-30 22:54:50.127341: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library cufft64_10.dll
2019-12-30 22:54:50.131871: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library curand64_10.dll
2019-12-30 22:54:50.139786: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library cusolver64_10.dll
2019-12-30 22:54:50.144940: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library cusparse64_10.dll
2019-12-30 22:54:50.159197: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library cudnn64_7.dll
2019-12-30 22:54:50.162685: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1700] Adding visible gpu devices: 0
TF GPU device: PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')



CUDA_PATH=C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.1
Tensorflow Version: 2.1.0-dev20191230
Tensorflow_addons Version: 0.7.0-dev



Preparing data
Loading dataset
100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 80/80 [00:03<00:00, 21.71it/s] 
100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 68/68 [00:00<00:00, 433.07it/s] 
Performing NLP
100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 80/80 [00:00<00:00, 13332.18it/s] 
100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 68/68 [00:00<?, ?it/s] 
Transforming dataset
Generating primitives and constructing vocabulary
100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 80/80 [00:00<00:00, 140.34it/s] 
100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 68/68 [00:00<00:00, 4249.55it/s] 
Encoding primitives
100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 16654/16654 [00:00<00:00, 33039.93it/s] 
100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 805/805 [00:00<00:00, 33537.43it/s] 
2019-12-30 22:55:04.084880: I tensorflow/core/platform/cpu_feature_guard.cc:142] Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX2
2019-12-30 22:55:04.088867: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1558] Found device 0 with properties:
pciBusID: 0000:08:00.0 name: GeForce GTX 1070 computeCapability: 6.1
coreClock: 1.7715GHz coreCount: 15 deviceMemorySize: 8.00GiB deviceMemoryBandwidth: 238.66GiB/s
2019-12-30 22:55:04.094516: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library cudart64_101.dll
2019-12-30 22:55:04.097049: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library cublas64_10.dll
2019-12-30 22:55:04.099754: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library cufft64_10.dll
2019-12-30 22:55:04.102329: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library curand64_10.dll
2019-12-30 22:55:04.105131: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library cusolver64_10.dll
2019-12-30 22:55:04.108029: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library cusparse64_10.dll
2019-12-30 22:55:04.110629: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library cudnn64_7.dll
2019-12-30 22:55:04.114339: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1700] Adding visible gpu devices: 0
2019-12-30 22:55:04.655119: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1087] TensorFlow compiled with CUDA 10.1 and cuDNN 7.6.5
2019-12-30 22:55:04.658124: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1099] Device interconnect StreamExecutor with strength 1 edge matrix:
2019-12-30 22:55:04.660826: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1105]      0
2019-12-30 22:55:04.662403: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1118] 0:   N
2019-12-30 22:55:04.664213: I tensorflow/core/common_runtime/gpu/gpu_device.cc:837] available_memory = 7038160076
2019-12-30 22:55:04.666185: I tensorflow/core/common_runtime/gpu/gpu_device.cc:838] min_system_memory = 351908003
2019-12-30 22:55:04.668490: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1370] GPUDevice PlatformGpuId 0 TfGpuId 0 on bus 1 numa: 0 pci: 0000:08:00.0 DeviceLocality: bus_id: 1
links {
}

2019-12-30 22:55:04.672820: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1244] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 6376 MB memory) -> physical GPU (device: 0, name: GeForce GTX 1070, pci bus id: 0000:08:00.0, compute capability: 6.1)
2019-12-30 22:55:04.677690: I tensorflow/core/common_runtime/gpu/gpu_device.cc:249] Created stream[0] = 0000021EC0CF5840
2019-12-30 22:55:04.679747: I tensorflow/core/common_runtime/gpu/gpu_device.cc:268] Created host_to_device_stream[0] = 0000021EC0CF58C0
2019-12-30 22:55:04.682343: I tensorflow/core/common_runtime/gpu/gpu_device.cc:273] Created device_to_host_stream[0] = 0000021EC0CF5940
2019-12-30 22:55:04.685266: I tensorflow/core/common_runtime/gpu/gpu_device.cc:289] Created device_to_device_stream[0] = 0000021EC0CF59C0

EDIT: मॉडल की जानकारी, अगर यह मदद करता है।

__________________________________________________________________________________________________
Layer (type)                    Output Shape         Param #     Connected to
==================================================================================================
Feature_1 (InputLayer)          [(None, 150)]        0
__________________________________________________________________________________________________
Feature_2 (InputLayer)          [(None, 150)]        0
__________________________________________________________________________________________________
embedding (Embedding)           (None, 150, 64)      5632        Feature_1[0][0]
__________________________________________________________________________________________________
embedding_1 (Embedding)         (None, 150, 64)      2944        Feature_2[0][0]
__________________________________________________________________________________________________
bidirectional (Bidirectional)   (None, 150, 128)     66048       embedding[0][0]
__________________________________________________________________________________________________
bidirectional_1 (Bidirectional) (None, 150, 128)     66048       embedding_1[0][0]
__________________________________________________________________________________________________
concatenate (Concatenate)       (None, 150, 256)     0           bidirectional[0][0]
                                                                 bidirectional_1[0][0]
__________________________________________________________________________________________________
bidirectional_2 (Bidirectional) (None, 64)           73984       concatenate[0][0]
__________________________________________________________________________________________________
dense (Dense)                   (None, 32)           2080        bidirectional_2[0][0]
__________________________________________________________________________________________________
dense_1 (Dense)                 (None, 1)            33          dense[0][0]
==================================================================================================
Total params: 216,769
Trainable params: 216,769
Non-trainable params: 0

TF 1.15 का उपयोग करते हुए एक न्यूनतम उदाहरण, और मुझे यह त्रुटि मिलती है। RTX 2070 और NVIDIA 440.44 और CUDA संस्करण 10.2 पर।

import tensorflow as tf
import tensorflow.keras.applications as applications
import tensorflow.keras.utils as utils
import numpy as np

num_samples = 1000
height = 224
width = 224
num_classes = 1000

model = applications.ResNet50(weights=None, input_shape=(height, width, 3), classes=num_classes)

parallel_model = utils.multi_gpu_model(model, gpus=2, cpu_relocation=True)
parallel_model.compile(loss='categorical_crossentropy', optimizer='rmsprop')

x = np.random.random((num_samples, height, width, 3))
y = np.random.random((num_samples, num_classes))

parallel_model.fit(x, y, epochs=20, batch_size=256)

print('all done')

Train on 1000 samples
Epoch 1/20
2020-02-06 15:06:40.524918: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcublas.so.10
2020-02-06 15:06:41.291528: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcudnn.so.7
2020-02-06 15:06:41.329183: W tensorflow/core/framework/cpu_allocator_impl.cc:81] Allocation of 822083584 exceeds 10% of system memory.
2020-02-06 15:06:42.082319: W tensorflow/core/framework/cpu_allocator_impl.cc:81] Allocation of 851705856 exceeds 10% of system memory.
2020-02-06 15:06:42.293092: W tensorflow/core/framework/cpu_allocator_impl.cc:81] Allocation of 822083584 exceeds 10% of system memory.
2020-02-06 15:06:43.173764: W tensorflow/core/framework/cpu_allocator_impl.cc:81] Allocation of 822083584 exceeds 10% of system memory.
2020-02-06 15:06:43.820074: E tensorflow/stream_executor/cuda/cuda_dnn.cc:329] Could not create cudnn handle: CUDNN_STATUS_INTERNAL_ERROR
2020-02-06 15:06:44.390897: W tensorflow/core/framework/cpu_allocator_impl.cc:81] Allocation of 822083584 exceeds 10% of system memory.
2020-02-06 15:06:45.839525: E tensorflow/stream_executor/cuda/cuda_dnn.cc:329] Could not create cudnn handle: CUDNN_STATUS_INTERNAL_ERROR
2020-02-06 15:06:45.856793: E tensorflow/stream_executor/cuda/cuda_dnn.cc:329] Could not create cudnn handle: CUDNN_STATUS_INTERNAL_ERROR
2020-02-06 15:06:45.883423: E tensorflow/stream_executor/cuda/cuda_dnn.cc:329] Could not create cudnn handle: CUDNN_STATUS_INTERNAL_ERROR
Traceback (most recent call last):
  File "./test_tf.py", line 19, in <module>
    parallel_model.fit(x, y, epochs=20, batch_size=256)
  File "/nix/store/520352w3m8lyj2zgv647qfqrws5q798n-python3.7-tensorflow-gpu-1.15.0/lib/python3.7/site-packages/tensorflow_core/python/keras/engine/training.py", line 727, in fit
    use_multiprocessing=use_multiprocessing)
  File "/nix/store/520352w3m8lyj2zgv647qfqrws5q798n-python3.7-tensorflow-gpu-1.15.0/lib/python3.7/site-packages/tensorflow_core/python/keras/engine/training_arrays.py", line 675, in fit
    steps_name='steps_per_epoch')
  File "/nix/store/520352w3m8lyj2zgv647qfqrws5q798n-python3.7-tensorflow-gpu-1.15.0/lib/python3.7/site-packages/tensorflow_core/python/keras/engine/training_arrays.py", line 394, in model_iteration
    batch_outs = f(ins_batch)
  File "/nix/store/520352w3m8lyj2zgv647qfqrws5q798n-python3.7-tensorflow-gpu-1.15.0/lib/python3.7/site-packages/tensorflow_core/python/keras/backend.py", line 3476, in __call__
    run_metadata=self.run_metadata)
  File "/nix/store/520352w3m8lyj2zgv647qfqrws5q798n-python3.7-tensorflow-gpu-1.15.0/lib/python3.7/site-packages/tensorflow_core/python/client/session.py", line 1472, in __call__
    run_metadata_ptr)
tensorflow.python.framework.errors_impl.UnknownError: 2 root error(s) found.
  (0) Unknown: Failed to get convolution algorithm. This is probably because cuDNN failed to initialize, so try looking to see if a warning log message was printed above.
    [[{{node replica_1/resnet50/conv1_conv/Conv2D}}]]
  (1) Unknown: Failed to get convolution algorithm. This is probably because cuDNN failed to initialize, so try looking to see if a warning log message was printed above.
    [[{{node replica_1/resnet50/conv1_conv/Conv2D}}]]
    [[training/RMSprop/gradients/gradients/Switch_482/_3893]]
0 successful operations.
1 derived errors ignored.

मैं एक अलग मुद्दे में इंगित करना चाहता हूं https://github.com/tensorflow/tensorflow/issues/36501 कि उन विकल्पों का उपयोग करते हुए कोड को चलाने में सक्षम बनाता है, GPU के वास्तविक स्मृति उपयोग को दर्शाता है कि यह वास्तव में अभी भी नहीं है वृद्धिशील स्मृति का उपयोग करना। इसलिए ऊपर दिया गया विकल्प त्रुटि को ठीक करता है, लेकिन यह वास्तव में ऐसा नहीं करता है जो यह करने का दावा करता है। मैं उसी मॉडल का उपयोग 1.2 या ... जैसे पुराने टीएफ संस्करणों में वापस करता था और वे वास्तविक वृद्धिशील मेमोरी आवंटन करते थे।

मुझे यहाँ सभी के समान समस्याएं हैं! टीएफ 2.1 स्थापित करने के बाद मुझे जीपीयू में मेमोरी वृद्धि को जोड़ने के बिना एक सरल एमएनआईएसटी उदाहरण नहीं मिल सकता है। मैं 2080 ti का उपयोग करता हूं।

मेरे सामने प्रमुख समस्या यह है कि मैं शंकु CUDNN आंतरिक त्रुटि को प्राप्त किए बिना tf 2.1 के साथ मिलकर टेंसोफ़्लो-प्रायिकता को नहीं चला सकता, यहां तक ​​कि कोड में मेमोरी वृद्धि को भी जोड़ा गया। मैंने tf 2.0, CUDA 10.0 और CUDA 10.1, विभिन्न CUDNN संस्करण स्थापित करने की कोशिश की है। मैं अपने ubuntu को पूरी तरह से पुनर्स्थापित करने के बाद विकास के बिना काम करने के लिए सरल MNIST उदाहरण को ठीक करने में कामयाब रहा, लेकिन टेंसरफ़्लो संभावना उदाहरण नहीं। मैंने अंततः एक टेंसरफ़्लो आधिकारिक रात्रिकालीन डॉकटर का उपयोग करने की कोशिश की और अभी भी टेंसरफ़्लो संभावना (टीएफ 2.2 कंटेनर के साथ) का उपयोग करते समय एक ही त्रुटि मिली। सीपीयू पर सब कुछ ठीक चलता है। मैंने 1080 ti वाली मशीन पर एक ही docker को चलाने की कोशिश की है और यह काम किया है ... मुझे लगता है कि RTX श्रृंखला में कुछ गड़बड़ है।

tf डॉकटर और टेंसरफ़्लो-प्रायिकता उदाहरण के साथ त्रुटि और अतिरिक्त cudnn डीबग जानकारी:

TF VERSION: 2.2.0-dev20200208
2020-02-11 08:51:05.891560: I tensorflow/core/platform/cpu_feature_guard.cc:143] Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX2 FMA
2020-02-11 08:51:05.912465: I tensorflow/core/platform/profile_utils/cpu_utils.cc:102] CPU Frequency: 3696000000 Hz
2020-02-11 08:51:05.913040: I tensorflow/compiler/xla/service/service.cc:168] XLA service 0x57b1fd0 initialized for platform Host (this does not guarantee that XLA will be used). Devices:
2020-02-11 08:51:05.913052: I tensorflow/compiler/xla/service/service.cc:176]   StreamExecutor device (0): Host, Default Version
2020-02-11 08:51:05.914414: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcuda.so.1
2020-02-11 08:51:05.975016: 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-02-11 08:51:05.975364: I tensorflow/compiler/xla/service/service.cc:168] XLA service 0x5679220 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:
2020-02-11 08:51:05.975376: I tensorflow/compiler/xla/service/service.cc:176]   StreamExecutor device (0): GeForce RTX 2080 Ti, Compute Capability 7.5
2020-02-11 08:51:05.975477: 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-02-11 08:51:05.975744: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1558] Found device 0 with properties: 
pciBusID: 0000:01:00.0 name: GeForce RTX 2080 Ti computeCapability: 7.5
coreClock: 1.545GHz coreCount: 68 deviceMemorySize: 10.75GiB deviceMemoryBandwidth: 573.69GiB/s
2020-02-11 08:51:05.975865: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcudart.so.10.1
2020-02-11 08:51:05.976745: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcublas.so.10
2020-02-11 08:51:05.977582: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcufft.so.10
2020-02-11 08:51:05.977722: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcurand.so.10
2020-02-11 08:51:05.978636: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcusolver.so.10
2020-02-11 08:51:05.979165: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcusparse.so.10
2020-02-11 08:51:05.981150: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcudnn.so.7
2020-02-11 08:51:05.981216: 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-02-11 08:51:05.981528: 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-02-11 08:51:05.981792: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1700] Adding visible gpu devices: 0
2020-02-11 08:51:05.981812: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcudart.so.10.1
2020-02-11 08:51:05.982323: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1099] Device interconnect StreamExecutor with strength 1 edge matrix:
2020-02-11 08:51:05.982331: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1105]      0 
2020-02-11 08:51:05.982335: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1118] 0:   N 
2020-02-11 08:51:05.982395: 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-02-11 08:51:05.982687: 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-02-11 08:51:05.982959: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1244] Created TensorFlow device (/device:GPU:0 with 9604 MB memory) -> physical GPU (device: 0, name: GeForce RTX 2080 Ti, pci bus id: 0000:01:00.0, compute capability: 7.5)
2020-02-11 08:51:05.983594: 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-02-11 08:51:05.983864: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1558] Found device 0 with properties: 
pciBusID: 0000:01:00.0 name: GeForce RTX 2080 Ti computeCapability: 7.5
coreClock: 1.545GHz coreCount: 68 deviceMemorySize: 10.75GiB deviceMemoryBandwidth: 573.69GiB/s
2020-02-11 08:51:05.983881: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcudart.so.10.1
2020-02-11 08:51:05.983889: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcublas.so.10
2020-02-11 08:51:05.983896: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcufft.so.10
2020-02-11 08:51:05.983904: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcurand.so.10
2020-02-11 08:51:05.983912: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcusolver.so.10
2020-02-11 08:51:05.983920: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcusparse.so.10
2020-02-11 08:51:05.983928: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcudnn.so.7
2020-02-11 08:51:05.983961: 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-02-11 08:51:05.984238: 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-02-11 08:51:05.984497: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1700] Adding visible gpu devices: 0
2020-02-11 08:51:05.984508: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1099] Device interconnect StreamExecutor with strength 1 edge matrix:
2020-02-11 08:51:05.984512: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1105]      0 
2020-02-11 08:51:05.984516: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1118] 0:   N 
2020-02-11 08:51:05.984563: 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-02-11 08:51:05.984842: 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-02-11 08:51:05.985099: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1244] Created TensorFlow device (/device:GPU:0 with 9604 MB memory) -> physical GPU (device: 0, name: GeForce RTX 2080 Ti, pci bus id: 0000:01:00.0, compute capability: 7.5)
SUCCESS: Found GPU: /device:GPU:0
2020-02-11 08:51:05.989382: 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-02-11 08:51:05.989649: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1558] Found device 0 with properties: 
pciBusID: 0000:01:00.0 name: GeForce RTX 2080 Ti computeCapability: 7.5
coreClock: 1.545GHz coreCount: 68 deviceMemorySize: 10.75GiB deviceMemoryBandwidth: 573.69GiB/s
2020-02-11 08:51:05.989663: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcudart.so.10.1
2020-02-11 08:51:05.989671: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcublas.so.10
2020-02-11 08:51:05.989678: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcufft.so.10
2020-02-11 08:51:05.989684: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcurand.so.10
2020-02-11 08:51:05.989691: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcusolver.so.10
2020-02-11 08:51:05.989700: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcusparse.so.10
2020-02-11 08:51:05.989709: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcudnn.so.7
2020-02-11 08:51:05.989744: 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-02-11 08:51:05.990021: 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-02-11 08:51:05.990347: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1700] Adding visible gpu devices: 0
2020-02-11 08:51:05.990544: 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-02-11 08:51:05.990807: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1558] Found device 0 with properties: 
pciBusID: 0000:01:00.0 name: GeForce RTX 2080 Ti computeCapability: 7.5
coreClock: 1.545GHz coreCount: 68 deviceMemorySize: 10.75GiB deviceMemoryBandwidth: 573.69GiB/s
2020-02-11 08:51:05.990820: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcudart.so.10.1
2020-02-11 08:51:05.990828: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcublas.so.10
2020-02-11 08:51:05.990834: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcufft.so.10
2020-02-11 08:51:05.990841: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcurand.so.10
2020-02-11 08:51:05.990848: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcusolver.so.10
2020-02-11 08:51:05.990854: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcusparse.so.10
2020-02-11 08:51:05.990861: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcudnn.so.7
2020-02-11 08:51:05.990892: 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-02-11 08:51:05.991171: 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-02-11 08:51:05.991426: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1700] Adding visible gpu devices: 0
2020-02-11 08:51:05.991437: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1099] Device interconnect StreamExecutor with strength 1 edge matrix:
2020-02-11 08:51:05.991441: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1105]      0 
2020-02-11 08:51:05.991444: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1118] 0:   N 
2020-02-11 08:51:05.991486: 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-02-11 08:51:05.991763: 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-02-11 08:51:05.992022: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1244] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 9604 MB memory) -> physical GPU (device: 0, name: GeForce RTX 2080 Ti, pci bus id: 0000:01:00.0, compute capability: 7.5)
WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow_core/python/ops/linalg/linear_operator_lower_triangular.py:158: calling LinearOperator.__init__ (from tensorflow.python.ops.linalg.linear_operator) with graph_parents is deprecated and will be removed in a future version.
Instructions for updating:
Do not pass `graph_parents`.  They will  no longer be used.
WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow_core/python/ops/linalg/linear_operator_lower_triangular.py:158: calling LinearOperator.__init__ (from tensorflow.python.ops.linalg.linear_operator) with graph_parents is deprecated and will be removed in a future version.
Instructions for updating:
Do not pass `graph_parents`.  They will  no longer be used.
2020-02-11 08:51:06.822991: W tensorflow/python/util/util.cc:319] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
Epoch 1/15
2020-02-11 08:51:07.907445: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcublas.so.10
2020-02-11 08:51:09.832694: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcudnn.so.7

I! CuDNN (v7604) function cudnnCreate() called:
i! Time: 2020-02-11T08:51:09.832722 (0d+0h+0m+4s since start)
i! Process=205; Thread=269; GPU=NULL; Handle=NULL; StreamId=NULL.

2020-02-11 08:51:10.409902: E tensorflow/stream_executor/cuda/cuda_dnn.cc:329] Could not create cudnn handle: CUDNN_STATUS_INTERNAL_ERROR

I! CuDNN (v7604) function cudnnCreate() called:
i! Time: 2020-02-11T08:51:10.410012 (0d+0h+0m+5s since start)
i! Process=205; Thread=269; GPU=NULL; Handle=NULL; StreamId=NULL.

2020-02-11 08:51:10.417952: E tensorflow/stream_executor/cuda/cuda_dnn.cc:329] Could not create cudnn handle: CUDNN_STATUS_INTERNAL_ERROR
      1/Unknown - 4s 4s/stepTraceback (most recent call last):
  File "VAE_MNIST_tfp.py", line 150, in <module>
    validation_data=eval_dataset)
  File "/usr/local/lib/python3.6/dist-packages/tensorflow_core/python/keras/engine/training.py", line 718, in fit
    use_multiprocessing=use_multiprocessing)
  File "/usr/local/lib/python3.6/dist-packages/tensorflow_core/python/keras/engine/training_v2.py", line 341, in fit
    total_epochs=epochs)
  File "/usr/local/lib/python3.6/dist-packages/tensorflow_core/python/keras/engine/training_v2.py", line 128, in run_one_epoch
    batch_outs = execution_function(iterator)
  File "/usr/local/lib/python3.6/dist-packages/tensorflow_core/python/keras/engine/training_v2_utils.py", line 98, in execution_function
    distributed_function(input_fn))
  File "/usr/local/lib/python3.6/dist-packages/tensorflow_core/python/eager/def_function.py", line 576, in __call__
    result = self._call(*args, **kwds)
  File "/usr/local/lib/python3.6/dist-packages/tensorflow_core/python/eager/def_function.py", line 640, in _call
    return self._stateless_fn(*args, **kwds)
  File "/usr/local/lib/python3.6/dist-packages/tensorflow_core/python/eager/function.py", line 2414, in __call__
    return graph_function._filtered_call(args, kwargs)  # pylint: disable=protected-access
  File "/usr/local/lib/python3.6/dist-packages/tensorflow_core/python/eager/function.py", line 1660, in _filtered_call
    self.captured_inputs)
  File "/usr/local/lib/python3.6/dist-packages/tensorflow_core/python/eager/function.py", line 1741, in _call_flat
    ctx, args, cancellation_manager=cancellation_manager))
  File "/usr/local/lib/python3.6/dist-packages/tensorflow_core/python/eager/function.py", line 598, in call
    ctx=ctx)
  File "/usr/local/lib/python3.6/dist-packages/tensorflow_core/python/eager/execute.py", line 60, in quick_execute
    inputs, attrs, num_outputs)
tensorflow.python.framework.errors_impl.UnknownError:  Failed to get convolution algorithm. This is probably because cuDNN failed to initialize, so try looking to see if a warning log message was printed above.
     [[node model/conv2d/Conv2D (defined at VAE_MNIST_tfp.py:150) ]] [Op:__inference_distributed_function_4291]

Errors may have originated from an input operation.
Input Source operations connected to node model/conv2d/Conv2D:
 model/lambda/sub (defined at VAE_MNIST_tfp.py:98)

Function call stack:
distributed_function

@sanjoy मैं RTX 2080 के साथ एक ही मुद्दा है और जरूरत पड़ने पर स्रोत से निर्माण कर सकता है।

@odinsbane आपको स्रोत से TensorFlow का निर्माण करना होगा जो मैं नीचे सुझाता हूं।

पहला कदम LOG(INFO) या std::cerr लाइनों को MinSystemMemory available_memory प्रिंट करना है और MinSystemMemory से वापसी मूल्य जोड़ना है। क्या available_memory nvidia-smi प्रिंट से सहमत हैं? हम सिस्टम के लिए कितनी स्मृति छोड़ रहे हैं?

दूसरी बात, क्या 0.05 मैजिक नंबर बढ़ाने के लिए, कहते हैं, 0.07 बिल्कुल भी मदद नहीं करता है?

इस बात की पुष्टि कर सकते हैं कि जादुई संख्या 0.05 जादू संख्या को 0.1 बदलने के साथ स्रोत से भवन समस्या को ठीक करने के लिए लगता है (कम से कम 1.15.2 के लिए)!

शोर के एक महासागर में न्यूनतम सिस्टम मेमोरी मैजिक नंबर पूरी तरह से तार्किक लगता है। साझा करने के लिए धन्यवाद!

@chsigg कोई सुझाव? शायद हम cuDNN, cuBLAS और अन्य NVIDIA पुस्तकालयों को शुरू करने की कोशिश कर सकते हैं _before_ हम GPU स्मृति के सभी को आरक्षित करते हैं?

हम डिफ़ॉल्ट रूप से allow_growth को सक्षम करने का भी प्रयास कर सकते हैं, लेकिन इसमें समय लगने वाला है।

यह समस्या मेरे RTX2080 से संबंधित है, मेरे पास एक डेस्कटॉप GTX1080 है, सब कुछ ठीक लगता है, तो मैं अपने RTX2080 नोटबुक के लिए कोंडा क्लोन का उपयोग करता हूं, मैं टेंसरफ़्लो 2.0.0-gpu का उपयोग करता हूं। एक बार एप्लिकेशन कोड के उपयोग के बाद Conv2d, LSTM, GRU तब यह परेशानी आती है।
इससे पहले कि मैं इस समस्या को हल करने के लिए निम्नलिखित कोड का उपयोग करूं:
gpus = tf.config.experimental.list_physical_devices ('GPU')
अगर gpus:
प्रयत्न:

वर्तमान में, मेमोरी ग्रोथ जीपीयू में समान होनी चाहिए

    for gpu in gpus:
        tf.config.experimental.set_memory_growth(gpu, True)
        logical_gpus = tf.config.experimental.list_logical_devices('GPU')
        print(len(gpus), "Physical GPUs,", len(logical_gpus), "Logical GPUs")
except RuntimeError as e:

जीपीयू को इनिशियलाइज़ करने से पहले मेमोरी ग्रोथ सेट करना होगा

    print(e)

लेकिन कई दिनों पहले से, उपरोक्त विधि किसी भी अधिक काम नहीं करती है

दिनों के लिए लैम्ब्डा Tensorflow2- ट्यूटोरियल बेसिक-इमेज-क्लासिफिकेशन कोड चलाने की कोशिश कर रहे हैं और जब तक मैंने आपके समाधान की कोशिश नहीं की, तब तक एक ही cudnn हैंडल त्रुटि हो रही है। यह आखिरकार अब आरटीएक्स 2070 मैक्स क्यू पर चल रहा है और न्यूनतम जीपीयू मेमोरी का उपयोग कर रहा है।

मैं इस समस्या को भी पूरा करता हूं
anacondacloud टेंसरफ़्लो-gpu2.0 स्थापित करें

rtx2070s
टेंसरफ्लो-gpu.2.0.0
क्यूडा 10.0.13
cudnn 7.6.5
Cudnn हैंडल नहीं बना सका: CUDNN_STATUS_INTERNAL_ERROR
कन्वेंशन एल्गोरिथ्म प्राप्त करने में विफल। यह संभवतः इसलिए है क्योंकि cuDNN आरंभ करने में विफल रहा, इसलिए यह देखने की कोशिश करें कि क्या चेतावनी लॉग संदेश ऊपर मुद्रित किया गया था।

मैं इस समस्या को भी पूरा करता हूं
anacondacloud टेंसरफ़्लो-gpu2.0 स्थापित करें

rtx2070s
टेंसरफ्लो-gpu.2.0.0
क्यूडा 10.0.13
cudnn 7.6.5
Cudnn हैंडल नहीं बना सका: CUDNN_STATUS_INTERNAL_ERROR
कन्वेंशन एल्गोरिथ्म प्राप्त करने में विफल। यह संभवतः इसलिए है क्योंकि cuDNN आरंभ करने में विफल रहा, इसलिए यह देखने की कोशिश करें कि क्या चेतावनी लॉग संदेश ऊपर मुद्रित किया गया था।

क्या आपने डाला:

gpus = tf.config.experimental.list_physical_devices('GPU')
if gpus:
try:
    for gpu in gpus:
        tf.config.experimental.set_memory_growth(gpu, True)
        logical_gpus = tf.config.experimental.list_logical_devices('GPU')
        print(len(gpus), "Physical GPUs,", len(logical_gpus), "Logical GPUs")
except RuntimeError as e:
    print(e)

आपके प्रवेश कोड के शीर्ष पर?

काफी समय के बाद tf.signal.stft के साथ एक स्पष्ट रूप से अलग समस्या के साथ प्रयोग करना
मैं आखिरकार इस धागे के पार आया और स्मृति वृद्धि की अनुमति देते हुए समाधान की कोशिश की। इसने मेरी समस्या को हल कर दिया।
मैंने टेनोरफ़्लो-जीपीयू = 2.1 को क्यूडाटुलकिट = 10.1 एनाकोंडा से स्थापित किया है, लेकिन साथ ही साथ स्थापित करने का भी प्रयास किया है
बिल्कुल उसी परिणाम के साथ पाइप के माध्यम से टेंसरफ़्लो-जीपीयू। मैं कार्ड के साथ linux-ubuntu 18.04 और डेबियन 9.12 के तहत इसे पुन: पेश कर सकता हूं

   GeForce GTX 1050 Ti with Max-Q Design   
   GeForce GTX 1050 Ti
   GeForce RTX 2080 Ti

मैंने हमारी लैब में दो अन्य कार्ड भी आजमाए

  GeForce GTX 1080 Ti
  TITAN Xp COLLECTORS EDITION

जहाँ कोड मेमोरी ग्रोथ की अनुमति के साथ और उसके बिना ठीक चलता है

मेरी न्यूनतम समस्या नीचे है। दिलचस्प है कि समस्या conv2d नहीं है। मैं इन तीन आदेशों के क्रम को बदल सकता हूं और यह हमेशा तीसरा होता है जो एक विफल रहता है।

import sys
import tensorflow as tf

gpus = tf.config.experimental.list_physical_devices('GPU')
if gpus and len(sys.argv)> 1 and sys.argv[1].startswith("-a"):
    print("allowing growth")
    growth = True
else:
    print("nogrowth")
    growth = False

try:
    for gpu in gpus:
        tf.config.experimental.set_memory_growth(gpu, growth)
        logical_gpus = tf.config.experimental.list_logical_devices('GPU')
        print(len(gpus), "Physical GPUs,", len(logical_gpus), "Logical GPUs")
except RuntimeError as e:
    print(e)

tf.signal.stft(tf.zeros(3000, dtype=tf.float32), 512, 128)
tf.matmul(tf.zeros((2,2,2)), tf.zeros((2,2,2)))
tf.nn.conv2d(tf.zeros((2,20,20,20), dtype=tf.float32),
                                         filters=tf.zeros((2,2,20,20), dtype=tf.float32),
            strides=(1,1,1,1), padding="VALID")
print("done")

मुझे भी इस समस्या का सामना करना पड़ा
anacondacloud टेंसरफ़्लो-gpu2.0 स्थापित करें
rtx2070s
टेंसरफ्लो- gpu.2.0.0
क्यूडा 10.0.13
cudnn 7.6.5
Cudnn हैंडल नहीं बना सका: CUDNN_STATUS_INTERNAL_ERROR
कनवल्शन एल्गोरिथ्म प्राप्त करने में असमर्थ। ऐसा इसलिए हो सकता है क्योंकि cuDNN प्रारंभ करने में विफल रहा, इसलिए कृपया यह देखने का प्रयास करें कि क्या ऊपर लॉग इन चेतावनी संदेश हैं।

क्या आपने डाला:

gpus = tf.config.experimental.list_physical_devices('GPU')
if gpus:
try:
    for gpu in gpus:
        tf.config.experimental.set_memory_growth(gpu, True)
        logical_gpus = tf.config.experimental.list_logical_devices('GPU')
        print(len(gpus), "Physical GPUs,", len(logical_gpus), "Logical GPUs")
except RuntimeError as e:
    print(e)

आपके द्वारा दर्ज कोड के शीर्ष पर?

हाँ, मैं इस तरह से इस समस्या को हल किया। धन्यवाद !!

मैं एक ही समस्या थी और allow_growth = True समाधान था। BUT, TensorFlow 2 के लिए, आपको निम्न पंक्तियों को जोड़ने की आवश्यकता है:

gpu_devices = tf.config.experimental.list_physical_devices('GPU') for device in gpu_devices: tf.config.experimental.set_memory_growth(device, True)

इस मुद्दे में उपयोगकर्ता @opcecco का धन्यवाद: https://github.com/tensorflow/tensorflow/issues/25256

दिलचस्प है कि समस्या conv2d नहीं है। मैं इन तीन आदेशों के क्रम को बदल सकता हूं और यह हमेशा तीसरा होता है जो एक विफल रहता है।

@roebel क्या आप कुछ भिन्न छह क्रमपरिवर्तन के लिए लॉग संलग्न कर सकते हैं?

और अगर आप कार्यक्रम को बदलते हैं तो क्या होगा (कहते हैं):

tf.signal.stft(tf.zeros(3000, dtype=tf.float32), 512, 128)
tf.signal.stft(tf.zeros(3000, dtype=tf.float32), 512, 128)
tf.signal.stft(tf.zeros(3000, dtype=tf.float32), 512, 128)
tf.signal.stft(tf.zeros(3000, dtype=tf.float32), 512, 128)
tf.matmul(tf.zeros((2,2,2)), tf.zeros((2,2,2)))
tf.nn.conv2d(tf.zeros((2,20,20,20), dtype=tf.float32),
                                         filters=tf.zeros((2,2,20,20), dtype=tf.float32),
            strides=(1,1,1,1), padding="VALID")

क्या विफलता अभी भी conv2d या क्या यह तीसरे stft ?

@sanjoy यकीन है कि स्क्रिप्ट के तीन रूपांतर ऊपर दिए गए हैं, जो आज्ञाओं के क्रम को बदलते हैं और एक चौथा संस्करण है जो 4 स्टैफ़्ट से शुरू होता है और कनवार्ड के साथ समाप्त होता है

चार विभिन्न लॉग स्क्रिप्ट से उपयोग करते हैं
https://github.com/tensorflow/tensorflow/issues/24496#issuecomment -595998686
अंतिम चार लाइनों की जगह।

आदेश के आधार पर संक्षेप में परिणाम:

stft-> blas-> conv2d जब acc2d निष्पादित करता है तो विफल रहता है
conv2d-> stft-> stas को निष्पादित करते समय ब्लास विफल हो जाता है (इसलिए तीसरा नहीं, लेकिन blas के लिए पहले से ही लोड हो रहा लगता है 2d
matmul-> conv2d-> एसटीएफ को निष्पादित करते समय स्टेप विफल हो जाता है
stft -> - stft -> - stft-> stft-> matmul-> conv2d जब acc2d निष्पादित होता है तो विफल हो जाता है। कृपया नीचे दिए गए लॉग देखें।

यदि आवश्यक हो तो अन्य वेरिएंट के लिए पूछना बुरा मत मानना।

conv2d अंतिम:

tf.matmul(tf.zeros((2,2,2)), tf.zeros((2,2,2)))
tf.signal.stft(tf.zeros(3000, dtype=tf.float32), 512, 128)
tf.nn.conv2d(tf.zeros((2,20,20,20), dtype=tf.float32),
                                         filters=tf.zeros((2,2,20,20), dtype=tf.float32),
            strides=(1,1,1,1), padding="VALID")
print("done")

log.conv2d.last.txt

मैतुल अंतिम

tf.nn.conv2d(tf.zeros((2,20,20,20), dtype=tf.float32),
                                         filters=tf.zeros((2,2,20,20), dtype=tf.float32),
            strides=(1,1,1,1), padding="VALID")
tf.signal.stft(tf.zeros(3000, dtype=tf.float32), 512, 128)
tf.matmul(tf.zeros((2,2,2)), tf.zeros((2,2,2)))
print("done")

log.matmul.last.txt

अंतिम समय

tf.matmul(tf.zeros((2,2,2)), tf.zeros((2,2,2)))
tf.nn.conv2d(tf.zeros((2,20,20,20), dtype=tf.float32),
                                         filters=tf.zeros((2,2,20,20), dtype=tf.float32),
            strides=(1,1,1,1), padding="VALID")
tf.signal.stft(tf.zeros(3000, dtype=tf.float32), 512, 128)
print("done")

log.stft.last.txt

4 स्टैफ्ट पहला कंफर्म 2d अंतिम:

tf.signal.stft(tf.zeros(3000, dtype=tf.float32), 512, 128)
tf.signal.stft(tf.zeros(3000, dtype=tf.float32), 512, 128)
tf.signal.stft(tf.zeros(3000, dtype=tf.float32), 512, 128)
tf.signal.stft(tf.zeros(3000, dtype=tf.float32), 512, 128)
tf.matmul(tf.zeros((2,2,2)), tf.zeros((2,2,2)))
tf.nn.conv2d(tf.zeros((2,20,20,20), dtype=tf.float32),
                                         filters=tf.zeros((2,2,20,20), dtype=tf.float32),
            strides=(1,1,1,1), padding="VALID")
print("done")

log.multi_stft.first.txt

बहुत धन्यवाद

मुझे निम्न कॉन्फ़िगरेशन के साथ एक ही समस्या मिली:
TensorFlow (स्रोत या बाइनरी) से स्थापित: r1.13.1, r.1.13.2, r1.14
पायथन संस्करण: 3.6.1
Bazel संस्करण (यदि स्रोत से संकलन):
जीसीसी / संकलक संस्करण (यदि स्रोत से संकलन):
CUDA / cuDNN संस्करण: CUDA 10 cuDNN 7.4.1 के साथ
GPU मॉडल और मेमोरी: RTX 2070 8GB।

मैंने इस समस्या को हल किया:
TensorFlow (स्रोत या बाइनरी) से स्थापित: r1.12.0
पायथन संस्करण: 3.6.9
जीसीसी / कंपाइलर संस्करण: 4.8
CUDA / cuDNN संस्करण: CUDA 9.0 cuDNN 7.1.4 के साथ
GPU मॉडल और मेमोरी: RTX 2070 8GB।
आशा है कि आप के लिए उपयोगी

मुझे ऐसी समस्या का भी सामना करना पड़ा है, जिसे पर्यावरण चर TF_FORCE_GPU_ALLOW_GROWTH = true द्वारा हल किया गया था।

कॉन्फ़िगरेशन निम्न है:
विंडोज 10
स्रोत r2.0 से संकलित Tensorflow
बाजेल: 0.26.1
C ++ कंपाइलर: MSVC 2017
CUDA: 10
cuDNN: 7.6.5

Intel4930 सीपीयू, एनवीडिया टाइटन एक्सपी पास्कल
Ubuntu 18.04.4, मिनिकोंडा नवीनतम,
`कोंडा सूची | grep "cud" देता है

    cudatoolkit               10.1.243             h6bb024c_0  
    cudnn                     7.6.5                cuda10.1_0  

`कोंडा सूची | grep "टेंसर" `` देता है

tensorboard               2.1.0                     py3_0  
tensorflow                2.1.0           gpu_py37h7a4bb67_0  
tensorflow-base           2.1.0           gpu_py37h6c5654b_0  
tensorflow-estimator      2.1.0              pyhd54b08b_0  
tensorflow-gpu            2.1.0                h0d30ee6_0  

ज्यूपिटर नोटबुक में पहली सेल है:

import tensorflow as tf
gpu_devices = tf.config.experimental.list_physical_devices('GPU')
for device in gpu_devices: tf.config.experimental.set_memory_growth(device, True)

मॉडल कुल परिमाण के साथ एक परिवर्तनशील ऑटोकेनोडर है: 112,269
x_train.shape, y_train.shape, x_test.shape, y_test.shape
((106496, 32, 32, 1), (106496,), (12288, 32, 32, 1), (12288,))

कोड शामिल हैं:

batch_size=64
var_auto_encoder.fit(x_train, x_train, verbose=1, 
                 batch_size=batch_size, epochs=100,
                 validation_data=(x_test, x_test))

और यह विफल रहता है। कंसोल शो

2020-03-18 15:46:03.019451: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcublas.so.10
2020-03-18 15:46:03.179472: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcudnn.so.7
2020-03-18 15:46:03.566267: E tensorflow/stream_executor/cuda/cuda_dnn.cc:329] Could not create cudnn handle: CUDNN_STATUS_INTERNAL_ERROR
2020-03-18 15:46:03.569842: E tensorflow/stream_executor/cuda/cuda_dnn.cc:329] Could not create cudnn handle: CUDNN_STATUS_INTERNAL_ERROR
2020-03-18 15:46:03.569907: W tensorflow/core/common_runtime/base_collective_executor.cc:217] BaseCollectiveExecutor::StartAbort Unknown: Failed to get convolution algorithm. This is probably because cuDNN failed to initialize, so try looking to see if a warning log message was printed above.
     [[{{node conv2d/Conv2D}}]]
2020-03-18 15:46:03.573206: E tensorflow/stream_executor/cuda/cuda_dnn.cc:329] Could not create cudnn handle: CUDNN_STATUS_INTERNAL_ERROR

मैं पहले सेल के बजाय f के रूप में ऊपर उल्लेख किया है, मैं का उपयोग करें

from tensorflow.compat.v1 import ConfigProto
from tensorflow.compat.v1 import InteractiveSession

config = ConfigProto()
config.gpu_options.per_process_gpu_memory_fraction = 0.2
config.gpu_options.allow_growth = True
session = InteractiveSession(config=config)

तब मुझे यह त्रुटि मिलती है

2020-03-18 15:55:43.050094: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcudart.so.10.1
2020-03-18 15:55:43.050123: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcublas.so.10
2020-03-18 15:55:43.050150: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcufft.so.10
2020-03-18 15:55:43.050177: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcurand.so.10
2020-03-18 15:55:43.050209: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcusolver.so.10
2020-03-18 15:55:43.050246: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcusparse.so.10
2020-03-18 15:55:43.050273: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcudnn.so.7
2020-03-18 15:55:43.050337: 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-03-18 15:55:43.050720: 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-03-18 15:55:43.051063: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1697] Adding visible gpu devices: 0
2020-03-18 15:55:43.051097: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1096] Device interconnect StreamExecutor with strength 1 edge matrix:
2020-03-18 15:55:43.051108: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1102]      0 
2020-03-18 15:55:43.051116: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1115] 0:   N 
2020-03-18 15:55:43.051201: 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-03-18 15:55:43.051573: 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-03-18 15:55:43.051915: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1241] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 16 MB memory) -> physical GPU (device: 0, name: TITAN X (Pascal), pci bus id: 0000:01:00.0, compute capability: 6.1)
2020-03-18 15:56:07.877181: E tensorflow/stream_executor/cuda/cuda_dnn.cc:329] Could not create cudnn handle: CUDNN_STATUS_INTERNAL_ERROR
2020-03-18 15:56:07.882424: E tensorflow/stream_executor/cuda/cuda_dnn.cc:329] Could not create cudnn handle: CUDNN_STATUS_INTERNAL_ERROR
2020-03-18 15:56:07.886148: E tensorflow/stream_executor/cuda/cuda_dnn.cc:329] Could not create cudnn handle: CUDNN_STATUS_INTERNAL_ERROR
2020-03-18 15:56:07.889830: E tensorflow/stream_executor/cuda/cuda_dnn.cc:329] Could not create cudnn handle: CUDNN_STATUS_INTERNAL_ERROR


Why am I having the problem if I allow memory growth? Do I need to reboot to reinitialize the gpu?

दिलचस्प बात यह है कि मेरे संघर्षों के दौरान, मुझे अपने मेनूबार में एक लाल 'नो एंट्री' साइन से एक संदेश मिला, जिसमें कहा गया था कि '' त्रुटि टूटी हुई गिनती आपके पास बिना किसी निर्भरता के है '
मैंने सॉफ़्टवेयर अपडेट चलाया और यह libcudn7-dev और libcudnn7-doc को हटाना चाहता है
साथ ही साथ 57 अन्य पुस्तकालयों को अपग्रेड करना है, जिनका लिनक्स के साथ क्या करना है

EDIT: मॉडल को रीबूट करने के बाद लगता है कि ट्रेन सफलतापूर्वक इसका उपयोग कर रही है:

from tensorflow.compat.v1 import ConfigProto
from tensorflow.compat.v1 import InteractiveSession

config = ConfigProto()
config.gpu_options.per_process_gpu_memory_fraction = 0.2
config.gpu_options.allow_growth = True
session = InteractiveSession(config=config)

या यह:

import tensorflow as tf
gpu_devices = tf.config.experimental.list_physical_devices('GPU')
for device in gpu_devices: tf.config.experimental.set_memory_growth(device, True)

जीपीयू पर मेमोरी उपयोग <700 एमबी बैच के आकार 16 के साथ और है
बैच आकार 256 के साथ ~ 1 गीगाबाइट (जो 3x तेज ट्रेन)

मैंने स्रोत से संकलन करने का प्रयास किया, लेकिन उसी मुद्दे में भाग गया। मैं अंत में अपनी समस्या को ठीक करने में सक्षम था config.gpu_options.allow_growth = True सेट कर रहा था।

लेकिन अगर मैं इस मुद्दे को कमांड लाइन में मिला, तो इन कोड को कैसे जोड़ा जाए?

मैं इस समस्या को भी पूरा करता हूं
anacondacloud टेंसरफ़्लो-gpu2.0 स्थापित करें
rtx2070s
टेंसरफ्लो-gpu.2.0.0
क्यूडा 10.0.13
cudnn 7.6.5
Cudnn हैंडल नहीं बना सका: CUDNN_STATUS_INTERNAL_ERROR
कन्वेंशन एल्गोरिथ्म प्राप्त करने में विफल। यह संभवतः इसलिए है क्योंकि cuDNN आरंभ करने में विफल रहा, इसलिए यह देखने की कोशिश करें कि क्या चेतावनी लॉग संदेश ऊपर मुद्रित किया गया था।

क्या आपने डाला:

gpus = tf.config.experimental.list_physical_devices('GPU')
if gpus:
try:
    for gpu in gpus:
        tf.config.experimental.set_memory_growth(gpu, True)
        logical_gpus = tf.config.experimental.list_logical_devices('GPU')
        print(len(gpus), "Physical GPUs,", len(logical_gpus), "Logical GPUs")
except RuntimeError as e:
    print(e)

आपके प्रवेश कोड के शीर्ष पर?

मुझे ऊपर जैसी ही समस्या थी। Could not create cudnn handle: CUDNN_STATUS_INTERNAL_ERROR

@Robosmith से समाधान मेरी समस्या को पूरी तरह से ठीक करता है!

मेरी ऐनक:
RTX 2070
उबंटू 18.04 एलटीई
टेंसरफ्लो 2.1.0
केरस 2.3.0
cudnn 7.6.5
cuda10.1.0
कोंडा 4.8.3
अजगर 3.7.7

conda install tensorflow-gpu keras माध्यम से निर्मित

आपको बहुत - बहुत धन्यवाद! यह पहली बार है कि मैंने TF-2 को काम में लिया है! और TF-1 ने पूरी तरह से काम करना बंद कर दिया, यही वजह है कि मैंने अपग्रेड करने और 'क्या होता है' देखने का फैसला किया!

धन्यवाद!

config.gpu_options.allow_growth = सच

जब आप टेंसरफ़्लो 2.0 का उपयोग करते हैं, तो आप उपयोग कर सकते हैं
tf.config.experimental.set_memory_growth(tf.config.list_physical_devices('GPU')[0], True)
यह कोड import tensorflow as tf लेकिन आपके कोड से पहले है।

मैंने स्रोत से संकलन करने का प्रयास किया, लेकिन उसी मुद्दे में भाग गया। मैं अंत में अपनी समस्या को ठीक करने में सक्षम था config.gpu_options.allow_growth = True सेट कर रहा था।

इस कोड को टेंसरफ़्लो और केरस उपयोगकर्ताओं दोनों के लिए तेज़ी से उपलब्ध कराने के लिए साझा किया गया है।
स्रोत यहाँ से

# Tensorflow
import tensorflow as tf
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
session = tf.Session(config=config, ...)


#And for Keras
from keras.callbacks import ModelCheckpoint
from keras.models import Model, load_model, save_model, Sequential
from keras.layers import Dense, Activation, Dropout, Input, Masking, TimeDistributed, LSTM, Conv1D
from keras.layers import GRU, Bidirectional, BatchNormalization, Reshape
from keras.optimizers import Adam
from keras.backend.tensorflow_backend import set_session
import tensorflow as tf
config = tf.ConfigProto()
config.gpu_options.allow_growth = True  # dynamically grow the memory used on the GPU
config.log_device_placement = True  # to log device placement (on which device the operation ran)
sess = tf.Session(config=config)
set_session(sess)  # set this TensorFlow session as the default session for Keras

बस में झंकार करना चाहता था और कहना चाहता था कि समस्या अभी भी है;

मेरी ऐनक:
उबंटू 20.04
NVIDIA RTX 2070
एनवीडिया_ड्राइव 440.64
Tensorflow-gpu 2.0.1 (कॉन्डा के माध्यम से स्थापित, जो स्वचालित रूप से Cudatoolkit और CuDNN को एक ही env में स्थापित करता है)
cudatoolkit 10.1.243
cudnn 7.6.5

समस्या को tf.config.experimental.set_memory_growth(tf.config.list_physical_devices('GPU')[0], True) द्वारा हल किया जाता है

हालाँकि यह वास्तविक फिक्स की तुलना में वर्क-अराउंड की तरह अधिक लगता है, और इन दिनों बहुत से लोगों के पास 20XX कार्ड हैं। संभवतः एक अद्यतन होना चाहिए जिसमें यह समस्या है।

अपडेट: चूंकि मैं डुअल-बूटिंग हूं, इसलिए मैंने विंडोज़ के लिए भी जांच करने की कोशिश की। समस्या वहां बनी रहती है।
विंडोज 10
एनवीडिया-चालक 445.87
इसके अलावा सब कुछ समान है

मेरे RTX 2080 के लिए नवीनतम ड्राइवर (445.87) स्थापित करने से मेरे लिए यह समस्या हल हो गई।

@NBouman यह दिलचस्प है, लेकिन मेरे लिए उबंटू 18.04 पर GeForce GTX 1050 TI के साथ, मैंने अभी पिछले उपलब्ध ड्राइवर 440.82 को अपडेट किया है। फिर भी इसे काम करने के लिए मेमोरी ग्रोथ की आवश्यकता होती है।

मेरे RTX 2080 के लिए नवीनतम ड्राइवर (445.87) स्थापित करने से मेरे लिए यह समस्या हल हो गई।

@NBouman आप किस OS का उपयोग कर रहे हैं? मैं Ubuntu 20.40 पर हूं, और नवीनतम उपलब्ध ड्राइवर मुझे मिल सकता है 440.82, और @roebel की तरह, समस्या बनी रहती है।

@roebel @eduardoscsouza मैं विंडोज 10 पर मशीन के साथ हूं जो पहले यह मुद्दा था।

बस में झंकार करना चाहता था और कहना चाहता था कि समस्या अभी भी है;

मेरी ऐनक:
उबंटू 20.04
NVIDIA RTX 2070
एनवीडिया_ड्राइव 440.64
Tensorflow-gpu 2.0.1 (कॉन्डा के माध्यम से स्थापित, जो स्वचालित रूप से Cudatoolkit और CuDNN को एक ही env में स्थापित करता है)
cudatoolkit 10.1.243
cudnn 7.6.5

समस्या को tf.config.experimental.set_memory_growth(tf.config.list_physical_devices('GPU')[0], True) द्वारा हल किया जाता है

हालाँकि यह वास्तविक फिक्स की तुलना में वर्क-अराउंड की तरह अधिक लगता है, और इन दिनों बहुत से लोगों के पास 20XX कार्ड हैं। संभवतः एक अद्यतन होना चाहिए जिसमें यह समस्या है।

अपडेट: चूंकि मैं डुअल-बूटिंग हूं, इसलिए मैंने विंडोज़ के लिए भी जांच करने की कोशिश की। समस्या वहां बनी रहती है।
विंडोज 10
एनवीडिया-चालक 445.87
इसके अलावा सब कुछ समान है

टेंसरफ्लो के लिए 2.0.0 ने साथ काम किया:
tf.config.experimental.set_memory_growth(tf.config.experimental.list_physical_devices('GPU')[0],True)

धन्यवाद!!! हज़ारों धन्यवाद !!!!!!!!!!!!!!!

ओएस: ubuntu 18.04 lts

चालक संस्करण: 435.21

कूडा: कुडाटुलकिट 10.1

CUDNN: cudnn-7.6.5-cuda10.1_0

मैंने एनाकोंडा को टेंसोफ़्लो स्थापित किया

conda create -n tf-gpu tensorflow-gpu

cudatoolkit और cudnn पहले कमांड के माध्यम से एनाकोंडा द्वारा ऑटो-इंस्टॉल किए जाते हैं।

मेरा एक ही सवाल है, त्रुटि:

coreClock: 1.5315GHz coreCount: 3 deviceMemorySize: 1.96GiB deviceMemoryBandwidth: 44.76GiB/s
2020-05-12 17:58:44.119679: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcudart.so.10.1
2020-05-12 17:58:44.119694: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcublas.so.10
2020-05-12 17:58:44.119707: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcufft.so.10
2020-05-12 17:58:44.119719: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcurand.so.10
2020-05-12 17:58:44.119732: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcusolver.so.10
2020-05-12 17:58:44.119744: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcusparse.so.10
2020-05-12 17:58:44.119756: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcudnn.so.7
2020-05-12 17:58:44.119819: 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-12 17:58:44.120069: 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-12 17:58:44.120277: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1697] Adding visible gpu devices: 0
2020-05-12 17:58:44.120308: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcudart.so.10.1
2020-05-12 17:58:44.174976: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1096] Device interconnect StreamExecutor with strength 1 edge matrix:
2020-05-12 17:58:44.175003: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1102]      0 
2020-05-12 17:58:44.175012: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1115] 0:   N 
2020-05-12 17:58:44.175136: 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-12 17:58:44.175392: 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-12 17:58:44.175624: 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-12 17:58:44.175844: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1241] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 1439 MB memory) -> physical GPU (device: 0, name: GeForce MX150, pci bus id: 0000:01:00.0, compute capability: 6.1)
2020-05-12 17:58:44.177113: I tensorflow/compiler/xla/service/service.cc:168] XLA service 0x55abc3d20b80 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:
2020-05-12 17:58:44.177129: I tensorflow/compiler/xla/service/service.cc:176]   StreamExecutor device (0): GeForce MX150, Compute Capability 6.1
2020-05-12 17:58:44.177749: W tensorflow/core/framework/cpu_allocator_impl.cc:81] Allocation of 376320000 exceeds 10% of system memory.
2020-05-12 17:58:44.787493: W tensorflow/core/framework/cpu_allocator_impl.cc:81] Allocation of 376320000 exceeds 10% of system memory.
WARNING:tensorflow:Layer my_model is casting an input tensor from dtype float64 to the layer's dtype of float32, which is new behavior in TensorFlow 2.  The layer has dtype float32 because it's dtype defaults to floatx.

If you intended to run this layer in float32, you can safely ignore this warning. If in doubt, this warning is likely only an issue if you are porting a TensorFlow 1.X model to TensorFlow 2.

To change all layers to have dtype float64 by default, call `tf.keras.backend.set_floatx('float64')`. To change just this layer, pass dtype='float64' to the layer constructor. If you are the author of this layer, you can disable autocasting by passing autocast=False to the base Layer constructor.

2020-05-12 17:58:45.311821: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcublas.so.10
2020-05-12 17:58:45.467966: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcudnn.so.7
2020-05-12 17:58:45.904025: E tensorflow/stream_executor/cuda/cuda_dnn.cc:329] Could not create cudnn handle: CUDNN_STATUS_INTERNAL_ERROR
2020-05-12 17:58:45.913861: E tensorflow/stream_executor/cuda/cuda_dnn.cc:329] Could not create cudnn handle: CUDNN_STATUS_INTERNAL_ERROR
2020-05-12 17:58:45.913978: W tensorflow/core/common_runtime/base_collective_executor.cc:217] BaseCollectiveExecutor::StartAbort Unknown: Failed to get convolution algorithm. This is probably because cuDNN failed to initialize, so try looking to see if a warning log message was printed above.
     [[{{node my_model/conv2d/Conv2D}}]]

तो हमारे यहाँ एक समस्या है जो अनसुलझी है (एक वर्कअराउंड के अलावा जो अधिक कुशल मेमोरी हैंडलिंग के लिए मेमोरी ग्रोथ का उपयोग नहीं करने के लिए आधिकारिक सिफारिशों के खिलाफ है)। देव टीम द्वारा बहुत अधिक प्रतिक्रिया नहीं दी गई है। मुझे आश्चर्य है क्योंकि?

यह बग बहुत सारे टेंसरफ़्लो संस्करणों (1.13, 2.0, 2.1) को प्रभावित करता है, अगर मैंने सही ढंग से देखा कि सभी समस्याएं cuda 10. के साथ होती हैं। कोड कई कार्डों पर ठीक चलता है लेकिन दूसरों पर नहीं।
क्या देव टीम का कोई व्यक्ति हमें बता सकता है कि क्या यह टोडोरफ्लो लेयर से अधिक क्यूडा चालक में समस्या की ओर संकेत करता है? उस स्थिति में यह निश्चित रूप से बग रिपोर्ट को NVIDIA समर्थन पृष्ठों पर प्रसारित करने में सहायक होगा। यह नहीं होगा?

टेनसफ़्लो देव टीम से कोई टिप्पणी कर सकता है कि वे इस बग को कैसे देखते हैं? क्या कोई इस पर गौर कर रहा है?

अगर लोग दो CuDNN 7 साझा पुस्तकालयों पथ या LD पुस्तकालय पथ पर जाँच कर रहे हैं। इस लाइब्रेरी में कोई छोटी या पैच संख्या नहीं है, लेकिन संस्करण बेमेल इस त्रुटि संदेश को जन्म दे सकता है।

मैंने NVIDIA पर एक बग रिपोर्ट खोली, मैं आपको बता दूंगा कि इससे क्या होता है।

@samhodge
वास्तव में libcudnn के कई संस्करण स्थापित हैं, प्रत्येक एनाकोंडा env का अपना संस्करण है।
आम तौर पर एनाकोंडा सही तरीके से स्थापित किए गए रथ के साथ स्थापित होता है, इसलिए सही पुस्तकालयों को प्राप्त नहीं करना मुश्किल होता है।

मैंने एक स्ट्रेस बनाया है और लाइब्रेरियों को पकड़ लिया है जो असफल होने पर खोले जाते हैं
वे लगातार एनाकोंडा env dir से आते हैं जो कि टेंसोफ़्लो पैकेज (नीचे देखें) को होस्ट करता है।
Libcuda के अलावा संस्करण 440.82 है और जिसे मैंने NVIDIA इंस्टॉलर के साथ संकलित किया है।

मैं अलग-अलग cudatoolkits और विभिन्न libcudnn के साथ अन्य anaconda env lib dirs में से एक को LD_LIBRARY_PATH सेट कर सकता हूं, ट्रेस एक ही रहता है।
ध्यान दें कि यह समस्या नहीं है कि lbcudnn नहीं है। यह हमेशा तीसरा libcuxyz पुस्तकालय है
इसका उपयोग किया गया है और यह केवल निर्दिष्ट GPU पर (मैंने अलग-अलग GPU के साथ अलग-अलग मशीनों पर एक ही इंस्टॉल स्क्रिप्ट का उपयोग किया है, कुछ काम नहीं करते हैं) और वे सभी काम करते हैं यदि मेमोरी ग्रोथ सक्षम है।

(tf2.1) m3088.roebel: (test_sd) 510> grep open trace.log  | grep libcu | grep -v -- -1
openat(AT_FDCWD, "/usr/lib/x86_64-linux-gnu/libcuda.so.1", O_RDONLY|O_CLOEXEC) = 4
openat(AT_FDCWD, "/data/anasynth/anaconda3/envs/tf2.1/lib/python3.7/site-packages/tensorflow_core/python/../../../../libcudart.so.10.1", O_RDONLY|O_CLOEXEC) = 11
openat(AT_FDCWD, "/data/anasynth/anaconda3/envs/tf2.1/lib/python3.7/site-packages/tensorflow_core/python/../../../../libcublas.so.10", O_RDONLY|O_CLOEXEC) = 11
openat(AT_FDCWD, "/data/anasynth/anaconda3/envs/tf2.1/lib/python3.7/site-packages/tensorflow_core/python/../../../.././libcublasLt.so.10", O_RDONLY|O_CLOEXEC) = 11
openat(AT_FDCWD, "/data/anasynth/anaconda3/envs/tf2.1/lib/python3.7/site-packages/tensorflow_core/python/../../../../libcufft.so.10", O_RDONLY|O_CLOEXEC) = 11
openat(AT_FDCWD, "/data/anasynth/anaconda3/envs/tf2.1/lib/python3.7/site-packages/tensorflow_core/python/../../../../libcurand.so.10", O_RDONLY|O_CLOEXEC) = 11
openat(AT_FDCWD, "/data/anasynth/anaconda3/envs/tf2.1/lib/python3.7/site-packages/tensorflow_core/python/../../../../libcusolver.so.10", O_RDONLY|O_CLOEXEC) = 11
openat(AT_FDCWD, "/data/anasynth/anaconda3/envs/tf2.1/lib/python3.7/site-packages/tensorflow_core/python/../../../../libcusparse.so.10", O_RDONLY|O_CLOEXEC) = 11
openat(AT_FDCWD, "/data/anasynth/anaconda3/envs/tf2.1/lib/python3.7/site-packages/tensorflow_core/python/../../../../libcudnn.so.7", O_RDONLY|O_CLOEXEC) = 11

मैं Ubuntu 20.04 पर GeForce RTX 2060 सुपर के साथ एक ही समस्या है। घने परतों के साथ एक एनएन अच्छी तरह से काम करता है। लेकिन CNN परतों के साथ मुझे Failed to get convolution algorithm. This is probably because cuDNN failed to initialize, so try looking to see if a warning log message was printed above.
tf.config.experimental.set_memory_growth(tf.config.list_physical_devices('GPU')[0], True) जोड़ने से त्रुटि पर कोई फर्क नहीं पड़ता।
मैंने https://www.tensorflow.org/install/gpu और nvidia-smi शो के अनुसार स्थापना का पालन किया:
Driver Version: 440.64.00 CUDA Version: 10.2
मेरा कोंडा env है:

cudatoolkit               10.1.243             h6bb024c_0  
cudnn                     7.6.5                cuda10.1_0  
tensorflow-gpu            2.1.0                h0d30ee6_0

1.15 के साथ एक conda env में मुझे वही त्रुटि मिल रही है। यह बहुत अच्छा होगा अगर इसे ठीक किया जा सके।

अपडेट करें

export TF_FORCE_GPU_ALLOW_GROWTH=true का उपयोग करने के बाद यह सब काम करता है। मैं इस धारणा का था कि tf.config.experimental.set_memory_growth(tf.config.list_physical_devices('GPU')[0], True) एक ही चीज़ के लिए होगा, लेकिन ऐसा नहीं है। मुझे लगता है कि इसे TensorFlow GPU सपोर्ट वेबपेज पर स्पष्ट रूप से कहा जाना चाहिए।

@samhodge
वास्तव में libcudnn के कई संस्करण स्थापित हैं, प्रत्येक एनाकोंडा env का अपना संस्करण है।
आम तौर पर एनाकोंडा सही तरीके से स्थापित किए गए रथ के साथ स्थापित होता है, इसलिए सही पुस्तकालयों को प्राप्त नहीं करना मुश्किल होता है।

मैंने एक स्ट्रेस बनाया है और लाइब्रेरियों को पकड़ लिया है जो असफल होने पर खोले जाते हैं
वे लगातार एनाकोंडा env dir से आते हैं जो कि टेंसोफ़्लो पैकेज (नीचे देखें) को होस्ट करता है।
Libcuda के अलावा संस्करण 440.82 है और जिसे मैंने NVIDIA इंस्टॉलर के साथ संकलित किया है।

मैं अलग-अलग cudatoolkits और विभिन्न libcudnn के साथ अन्य anaconda env lib dirs में से एक को LD_LIBRARY_PATH सेट कर सकता हूं, ट्रेस एक ही रहता है।
ध्यान दें कि यह समस्या नहीं है कि lbcudnn नहीं है। यह हमेशा तीसरा libcuxyz पुस्तकालय है
इसका उपयोग किया गया है और यह केवल निर्दिष्ट GPU पर (मैंने अलग-अलग GPU के साथ अलग-अलग मशीनों पर एक ही इंस्टॉल स्क्रिप्ट का उपयोग किया है, कुछ काम नहीं करते हैं) और वे सभी काम करते हैं यदि मेमोरी ग्रोथ सक्षम है।

(tf2.1) m3088.roebel: (test_sd) 510> grep open trace.log  | grep libcu | grep -v -- -1
openat(AT_FDCWD, "/usr/lib/x86_64-linux-gnu/libcuda.so.1", O_RDONLY|O_CLOEXEC) = 4
openat(AT_FDCWD, "/data/anasynth/anaconda3/envs/tf2.1/lib/python3.7/site-packages/tensorflow_core/python/../../../../libcudart.so.10.1", O_RDONLY|O_CLOEXEC) = 11
openat(AT_FDCWD, "/data/anasynth/anaconda3/envs/tf2.1/lib/python3.7/site-packages/tensorflow_core/python/../../../../libcublas.so.10", O_RDONLY|O_CLOEXEC) = 11
openat(AT_FDCWD, "/data/anasynth/anaconda3/envs/tf2.1/lib/python3.7/site-packages/tensorflow_core/python/../../../.././libcublasLt.so.10", O_RDONLY|O_CLOEXEC) = 11
openat(AT_FDCWD, "/data/anasynth/anaconda3/envs/tf2.1/lib/python3.7/site-packages/tensorflow_core/python/../../../../libcufft.so.10", O_RDONLY|O_CLOEXEC) = 11
openat(AT_FDCWD, "/data/anasynth/anaconda3/envs/tf2.1/lib/python3.7/site-packages/tensorflow_core/python/../../../../libcurand.so.10", O_RDONLY|O_CLOEXEC) = 11
openat(AT_FDCWD, "/data/anasynth/anaconda3/envs/tf2.1/lib/python3.7/site-packages/tensorflow_core/python/../../../../libcusolver.so.10", O_RDONLY|O_CLOEXEC) = 11
openat(AT_FDCWD, "/data/anasynth/anaconda3/envs/tf2.1/lib/python3.7/site-packages/tensorflow_core/python/../../../../libcusparse.so.10", O_RDONLY|O_CLOEXEC) = 11
openat(AT_FDCWD, "/data/anasynth/anaconda3/envs/tf2.1/lib/python3.7/site-packages/tensorflow_core/python/../../../../libcudnn.so.7", O_RDONLY|O_CLOEXEC) = 11

तो तुम मेरी बात को दर्शाता हुआ की तरह कर रहे हैं libcudnn.so.7 कहना नहीं है 7.XXX.YYY उसके ऊपर 7.XXX.YYY CUDA पर है एक और dependancy 10.2 10.1 10.0 9.2 9.1 9.0 आदि

मैंने तब से त्रुटि नहीं देखी है जब से मैंने अच्छी तरह से पथ का प्रबंधन शुरू कर दिया है और किसी ज्ञात आकार के ग्राफ को शुरू करने से पहले उपलब्ध स्मृति की मात्रा को प्रबंधित करना और यह सुनिश्चित करना है कि लक्षित GPU केवल ग्राफ़ के लिए पर्याप्त स्मृति और क्वेरी के लिए पर्याप्त मेमोरी का उपयोग करता है कितना CUDA स्मृति उपलब्ध है।

मुझे लगता है कि यह एक संसाधन समस्या है। जब आप प्रक्रिया शुरू करते हैं तो कितनी मेमोरी उपलब्ध है और आपके ग्राफ का कितना मेमोरी उपयोग होता है?

@ कॉग्नेट-डॉक्स

तो आप मेरी बात को गलत समझ रहे हैं।

आपने जो सवाल उठाया था, "क्या लोग चेक कर रहे हैं कि क्या रास्ते में दो एलडीएनएन 7 साझा पुस्तकालय या एलडी लाइब्रेरी पथ हैं"। और मेरा जवाब था: मैंने यह जाँच की है, केवल एक ही है।
मैंने आपको ट्रेस भेजा है।

जब से मैंने पथ को प्रबंधित करना शुरू किया है मैंने त्रुटि नहीं देखी है

रास्ते का प्रबंधन करने से आपका क्या मतलब है?
मैं हमेशा अपने रास्तों का प्रबंधन करता हूं! मैंने एक कोंडा पर्यावरण स्थापित किया है जिसे मैंने सुसंगत होने के लिए सत्यापित किया है! सब कुछ वैसा ही है जैसा एनाकोंडा द्वारा पैक किया गया है, मैंने इसे सत्यापित किया।

वैसे भी आप विश्वास कर सकते हैं कि मैं बहुत मूर्ख हूं, एनाकोंडा स्थापित करने के लिए। कुंआ
मैंने अब आधिकारिक डॉकटर छवि डाउनलोड की है

टेंसरफ़्लो / टी एनसेंफ़्लो: 2.1.0-gpu-py3

और वहां मेरी स्क्रिप्ट चलाएं। अगर मेरे पास नहीं है तो यह दुर्घटनाग्रस्त हो जाता है

निर्यात TF_FORCE_GPU_ALLOW_GROWTH = सच

क्या मैं किसी भी बेहतर पथ का प्रबंधन कर सकता हूं?

और ज्ञात आकार के एक ग्राफ को शुरू करने से पहले उपलब्ध स्मृति की मात्रा को प्रबंधित करना और यह सुनिश्चित करना कि लक्षित GPU ने केवल ग्राफ़ के लिए पर्याप्त मेमोरी और पर्याप्त मेमोरी का उपयोग करके क्वेरी करने के लिए कि कितना CUDA मेमोरी उपलब्ध है।

मुझे लगता है कि यह एक संसाधन समस्या है। जब आप प्रक्रिया शुरू करते हैं तो कितनी मेमोरी उपलब्ध है और आपके ग्राफ का कितना मेमोरी उपयोग होता है?

जैसा कि मैंने अपनी रिपोर्ट में ऊपर लिखा है कि कोई ग्राफ नहीं है (या बेहतर कहें तो शायद ही कोई ग्राफ हो)! मैं सिर्फ इन चार लाइनों को चलाता हूं

import tensorflow as tf
tf.signal.stft(tf.zeros(3000, dtype=tf.float32), 512, 128)
tf.matmul(tf.zeros((2,2,2)), tf.zeros((2,2,2)))
tf.nn.conv2d(tf.zeros((2,20,20,20), dtype=tf.float32), filters=tf.zeros((2,2,20,20), dtype=tf.float32), strides=(1,1,1,1), padding="VALID")

और यह दुर्घटनाग्रस्त हो जाता है। अगर मैं तीन लाइनों के क्रम को बदल देता हूं तो यह इन तीन ऑपरेशनों के बाद हमेशा क्रैश हो जाता है (मैंने अपनी बग रिपोर्ट में यह समझाया था)।

बस इसके मज़े के लिए मैंने बाइट्स गिना: <83kB डेटा मेमोरी आवश्यक है। GPU खाली है, मैं इसका उपयोग ग्राफिक्स के लिए नहीं करता, और इस पर कोई अन्य प्रक्रिया नहीं चल रही है। विभिन्न प्रणालियों पर 4GB या 11GB उपलब्ध हैं! इसके अलावा मैं nvidia-smi चलाना जानता हूँ! तो कार्ड खाली है फिर भी मैं इन 4 लाइनों को नहीं चला सकता जिनके लिए 84kB की आवश्यकता होती है!

आपकी जानकारी के लिए, स्मृति समाप्त हो जाने के कारण एक त्रुटि काफी भिन्न रूप से दिखाई देती है, मेरे पास ये भी हैं। अपने वास्तविक रेखांकन के लिए, मैं इनका पता लगाने और तदनुसार प्रतिक्रिया करने में बहुत सक्षम हूं।

वैसे भी आपके प्रयासों के लिए धन्यवाद।

@roebel आपने cpp से डिबगिंग के बारे में @sanjoy की टिप्पणी देखी थी https://github.com/tensorflow/tensorflow/issues/24496#issuecomment -561366750?

मैंने टेंसरफ़्लो को पुनः प्राप्त करने और इसे आज़माने के लिए आस-पास नहीं देखा है। उनके संस्करण इतनी तेजी से आगे बढ़ते हैं कि मुझे सेटअप करने और सब कुछ संकलित करने में थोड़ा समय लगेगा। इसके अलावा, मेरे द्वारा उपयोग किए गए gcc संस्करण के लिए 1.15 ने समर्थन छोड़ दिया, और 1.13 को कोई भी अपडेट प्राप्त नहीं हुआ, इसलिए मेरे लिए यह वैसे भी डिबग करना कुछ हद तक बेकार था।

@roebel मुझे याद नहीं आया कि आपके लिए क्या समस्या है।

इसे देखें https://github.com/tensorflow/tensorflow/issues/24496#issuecomment -450549043

यही कारण है कि मुझे लगा कि यह स्मृति से संबंधित है, इस मुद्दे ने मुझे कुछ समय के लिए प्रभावित नहीं किया है, और न ही विभिन्न प्लेटफार्मों पर मेरे सॉफ़्टवेयर के उपयोगकर्ता।

@samhodge

हां, मैं समझता हूं कि अगर कोई बग है तो ऐसा लगता है कि यह केवल एक विशेष स्थिति से शुरू होता है।

@odinsbane

धन्यवाद, नहीं, मैंने उस पर ध्यान नहीं दिया था। मैं देखूंगा कि क्या सबसे हालिया संस्करण tf2.2.0 को संकलित करना है।

वास्तव में मैंने टेंसरफ्लो 2.2 के साथ डॉकटर की कोशिश की, यह क्यूडा 10.1 के समान संस्करण का उपयोग करता है और इसमें भी यही समस्या है।

सोचा था कि यह केवल एक समस्या थी, इसलिए मैंने स्क्रैच से एक ubuntu पर्यावरण स्थापित किया, केवल यह पता लगाने के लिए कि यह मेरा ग्राफिक्स कार्ड (RTX 2080) है जो कि समस्या है। दुर्भाग्य से मुझे लगता है कि मैं इस मुद्दे के कारण एक अलग मशीन लर्निंग प्लेटफॉर्म का चयन करने जा रहा हूं, क्योंकि ऐसा लगता है कि 2018 के बाद से यह एक समस्या है।

@ कॉग्नेट-डॉक्स

और ज्ञात आकार के एक ग्राफ को शुरू करने से पहले उपलब्ध स्मृति की मात्रा को प्रबंधित करना और यह सुनिश्चित करना कि लक्षित GPU ने केवल ग्राफ़ के लिए पर्याप्त मेमोरी और पर्याप्त मेमोरी का उपयोग करके क्वेरी करने के लिए कि कितना CUDA मेमोरी उपलब्ध है।

मुझे लगता है कि यह एक संसाधन समस्या है। जब आप प्रक्रिया शुरू करते हैं तो कितनी मेमोरी उपलब्ध है और आपके ग्राफ का कितना मेमोरी उपयोग होता है?

जैसा कि मैंने अपनी रिपोर्ट में ऊपर लिखा है कि कोई ग्राफ नहीं है (या बेहतर कहें तो शायद ही कोई ग्राफ हो)! मैं सिर्फ इन चार लाइनों को चलाता हूं

import tensorflow as tf
tf.signal.stft(tf.zeros(3000, dtype=tf.float32), 512, 128)
tf.matmul(tf.zeros((2,2,2)), tf.zeros((2,2,2)))
tf.nn.conv2d(tf.zeros((2,20,20,20), dtype=tf.float32), filters=tf.zeros((2,2,20,20), dtype=tf.float32), strides=(1,1,1,1), padding="VALID")

और यह दुर्घटनाग्रस्त हो जाता है। अगर मैं तीन लाइनों के क्रम को बदल देता हूं तो यह इन तीन ऑपरेशनों के बाद हमेशा क्रैश हो जाता है (मैंने अपनी बग रिपोर्ट में यह समझाया था)।

बस इसके मज़े के लिए मैंने बाइट्स गिना: <83kB डेटा मेमोरी आवश्यक है। GPU खाली है, मैं इसका उपयोग ग्राफिक्स के लिए नहीं करता, और इस पर कोई अन्य प्रक्रिया नहीं चल रही है। विभिन्न प्रणालियों पर 4GB या 11GB उपलब्ध हैं! इसके अलावा मैं nvidia-smi चलाना जानता हूँ! तो कार्ड खाली है फिर भी मैं इन 4 लाइनों को नहीं चला सकता जिनके लिए 84kB की आवश्यकता होती है!

क्या आपने देखा कि जब आप प्रक्रिया को 50 ms के अंतराल के साथ चला रहे थे, तो nvidia-smi पर घड़ी का उपयोग करके कितनी मेमोरी का उपयोग किया गया था?

इस सुधार को देखें जो अन्य लोगों के लिए काम करता है

https://github.com/tensorflow/tensorflow/issues/24496#issuecomment -492-2226

यहाँ 4 साल पहले से संबंधित पोस्ट है।

https://stackoverflow.com/questions/34199233/how-to-prevent-tensorflow-from-allocating-the-totality-of-a-gpu-memory

या आप दोस्ताना मैनुअल पढ़ सकते हैं:
https://www.tensorflow.org/guide/gpu#limiting_gpu_memory_growth

तो आप अपने रनटाइम वातावरण को बदलकर कोड को छूने के बिना पैच कर सकते हैं।

Another way to enable this option is to set the environmental variable TF_FORCE_GPU_ALLOW_GROWTH to true. This configuration is platform specific.

@sanjoy @odinsbane

खुशखबरी!
निम्नलिखित
https://github.com/tensorflow/tensorflow/issues/24496#issuecomment -561666450

मैंने यहाँ से एनाकोंडा टेंसरफ़्लो रेसिपी का उपयोग करके संस्करण 2.1 का पुनर्निर्माण किया है
https://github.com/AnacondaRecipes/tensorflow_recipes

मैंने MinSystemMemory में दो प्रिंट जोड़े जो उपलब्ध_मेरी और min_system_memory दिखा रहा है।
टीएफ मानक लॉग को अक्षम करने वाले GeForce GTX 1050 Ti साथ मेरे सिस्टम पर
मुझे यह मिल गया है

TF_CPP_MIN_LOG_LEVEL=2 python run_cuda.py 
=========================================================
MinSystemMemory: available_memory::4163764224
MinSystemMemory: min_system_memory::314572800
=========================================================
1 Physical GPUs, 1 Logical GPUs
2020-05-21 09:44:32.143642: E tensorflow/stream_executor/cuda/cuda_fft.cc:223] failed to make cuFFT batched plan:5
2020-05-21 09:44:32.143671: E tensorflow/stream_executor/cuda/cuda_fft.cc:426] Initialize Params: rank: 1 elem_count: 512 input_embed: 512 input_stride: 1 input_distance: 512 output_embed: 257 output_stride: 1 output_distance: 257 batch_count: 20
2020-05-21 09:44:32.143677: F tensorflow/stream_executor/cuda/cuda_fft.cc:435] failed to initialize batched cufft plan with customized allocator: Failed to make cuFFT batched plan.
Aborted

nvidia-smi की रिपोर्ट में GPU में 4040MiB है, इस प्रणाली पर कार्ड पर X चल रहा है जिसमें 13MiB है ताकि संख्या ठीक लगे।

min_system_memory इस तरह सेट की जाती है

    min_system_memory =                                                                                                                        
        std::max(int64{314572800}, static_cast<int64>(available_memory * 0.05));                                                               

तो अधिकतम राशि ओ मेमोरी को वैसे भी चुना जाता है। इसके बजाय मैंने पर्यावरण चर TF_FORCE_MIN_SYSTEM_MEMORY_MB के माध्यम से min_system_memory को बाध्य करने के लिए एक तंत्र जोड़ा।
फिर दौड़ रहा है

TF_FORCE_MIN_SYSTEM_MEMORY_MB=310 TF_CPP_MIN_LOG_LEVEL=2 python run_cuda.py 
=========================================================
MinSystemMemory: available_memory::4163764224
MinSystemMemory: min_system_memory::314572800
MinSystemMemory: forced min_system_memory::325058560
=========================================================
1 Physical GPUs, 1 Logical GPUs
done

समस्या सुलझ गई है!

दुर्भाग्य से मेरे पास वर्तमान में काम करने वाले RTX कार्ड के साथ एक प्रणाली नहीं है और मुझे यकीन नहीं है कि जब वे वापस काम करेंगे। अगर कोई भी इस तरह के कार्ड पर यह परीक्षण करने के लिए तैयार होता है तो मैं ubuntu linux के लिए पाइप पैकेज और कोंडा पर्यावरण की सामग्री प्रदान कर सकता हूं जिसे इसे चलाने के लिए स्थापित करने की आवश्यकता है।

अच्छा एक @roebel !

यह सुझाव के लायक हो सकता है कि पुल अनुरोध के रूप में और डॉक्स में जोड़ें।

@samhodge @sanjoy @odinsbane

यह सुझाव के लायक हो सकता है कि पुल अनुरोध के रूप में और डॉक्स में जोड़ें।

ज़रूर, लेकिन समस्या यह है कि समाधान शायद अन्य कार्ड के लिए काम नहीं करेगा।
मेरे GTX 1050 के लिए कुल मेमोरी 4GB है और डिफ़ॉल्ट सिस्टम मेमोरी बरकरार है
टेंसोफ़्लो द्वारा अधिकतम (300MB, 4GB * 0.05) है। तो GTX1050 के लिए यह 300MB होगा जो जाहिरा तौर पर बहुत छोटा है। जैसा कि ऊपर उल्लेख किया गया है, मुझे 310 एमबी तक बढ़ाने की आवश्यकता है।

RTX2080 के लिए अब कुल मेमोरी 11GB है जो अधिकतम (300MB, 11GB * 0.05) है
सिस्टम मेमोरी का चयन 550MB करने के लिए करेगा, जो कि 1050 के निष्कर्षों के अनुसार है
आम तौर पर पर्याप्त होना चाहिए।

मैं सप्ताह के अंत तक फिर से आरटीएक्स 2080 जीपीयू तक पहुंच पाऊंगा और देखूंगा
मुझे वहाँ क्या मिलता है

@samhodge @sanjoy @odinsbane

अंत में मैं rtx 2080 कार्ड पर पैच की गई लाइब्रेरी को चलाने में सक्षम हूं।
उम्मीद के मुताबिक पैचेड वर्जन पास नहीं होता है। यहाँ फिर से स्क्रिप्ट

import tensorflow as tf
tf.signal.stft(tf.zeros(3000, dtype=tf.float32), 512, 128)
tf.matmul(tf.zeros((2,2,2)), tf.zeros((2,2,2)))
tf.nn.conv2d(tf.zeros((2,20,20,20), dtype=tf.float32), filters=tf.zeros((2,2,20,20), dtype=tf.float32), strides=(1,1,1,1), padding="VALID")

और यहाँ gpu_device.cc से available memory का मैट्रिक्स बताया गया है:
डिफ़ॉल्ट मूल्य Min_system_memory रूप में gpu_device.cc और में चयनित
min value of the min_system_memory मुझे गर्भपात नहीं करने के लिए स्क्रिप्ट का चयन करने की आवश्यकता है:

कार्ड | AvailMem | Def MinSysMem | आवश्यक MinSysMem
: ------- |: ----------- |: ---------- |: --------------- --------
1050 टीआई | 4163764224 | 314572800 | 325058560 है
1080 TI | 11567431680 | 578371584 | 335544320 है
2080 टीआई | 11381964800 | 569098240 | 618659840 है

तो जबकि 1050 और 1080 एक ही मेमोरी आकार के साथ स्क्रिप्ट चलाते हैं
RTX2080 को लगभग दोगुनी मेमोरी की आवश्यकता होती है। यह अच्छा नहीं लगता
मेरे लिए।

किसी भी सुझाव क्या यह एक तुलनीय मूल्य के लिए प्राप्त करने की कोशिश?

@roebel

मैंने अपने C ++ एप्लिकेशन में कई पुनरावृत्तियों के लिए इसके साथ संघर्ष किया है।

अंत में जो आया है वह निम्नलिखित था।

मॉडल को चलाने के लिए पर्याप्त मेमोरी उपलब्ध होने पर ही GPU पर मॉडल चलाएं।

तो स्मृति की मात्रा जो मॉडल की आवश्यकता होगी वह मात्रात्मक है।

तो आपको एक प्रतिशत के रूप में GPU मेमोरी की आवश्यकता होगी जो उस मॉडल को फिट करेगी।

फिर आपको यह भी पता होना चाहिए कि मेमोरी आवंटित करने से ठीक पहले कार्ड पर कितनी मेमोरी उपलब्ध है, जो कि दौड़ की स्थिति के अधीन है, क्योंकि आप नहीं जानते कि ऑपरेटिंग सिस्टम पर उसी समय CUDA मेमोरी का और क्या उपयोग कर रहा है।

लेकिन दौड़ की स्थिति एक तरफ, आपको मेमोरी को मुफ्त में मापने की भी आवश्यकता है।

यह cudaMemInfo का उपयोग करके किया जाता है, जो अपने आप में स्मृति का उपयोग करता है।

तो इस प्रावधान पर कि आपके पास मापने के लिए cudaMemInfo एक बार चलाने के लिए पर्याप्त मेमोरी है और आपको यह सुनिश्चित करने की आवश्यकता है कि मॉडल को फिट करने के लिए पर्याप्त मेमोरी मुफ़्त है और cudaMemInfo एक बार और चलाने के लिए, तब और केवल तब आप मॉडल को चलाने के लिए उस कार्ड पर उपलब्ध वीआरएएम के प्रतिशत का पर्याप्त आवंटन कर सकते हैं।

वैसे भी मेरी बेतरतीब बड़बड़ा से घर ले लो cudaMemInfo लिए आवश्यक है कि जो अपने आप में उपलब्ध स्मृति को आवंटित करने के लिए भी उपलब्ध स्मृति का उपयोग करता है।

हो सकता है कि किसी तरह Pascal आधारित कार्ड की तुलना में cudaMemInfo द्वारा उपयोग की जाने वाली मेमोरी की मात्रा ट्यूरिंग आधारित कार्ड पर भिन्न हो, यदि आप चाहें तो मैं किसी से भी लुक प्राप्त कर सकता हूँ।

हाँ, मुझे cudaMemInfo संदर्भ बिल्कुल नहीं मिल रहा है लेकिन यह उस तरह के पदचिह्न की तरह लगता है जो अधिकतम 300Mb और कार्ड की मेमोरी का 5% होगा।

पर एक नज़र रखना:

https://github.com/tensorflow/tensorflow/blob/r2.2/tensorflow/core/common_runtime/gpu/gpu_process_state.cc

ऐसा लगता नहीं है कि यह प्रति se का उपयोग कर रहा है।

मुझे नहीं लगता कि हमें सिस्टम लाइब्रेरी के लिए आरक्षित किए जाने वाले मेमोरी की मात्रा के साथ बिल्ली-और-माउस खेलना चाहिए - जैसा कि आपने देखा है, यह अधिकार प्राप्त करने का कोई व्यवस्थित तरीका नहीं है।

IMO के बजाय हमें सिस्टम पुस्तकालयों को आरम्भ करने का प्रयास करना चाहिए, इससे पहले कि BFC आवंटनकर्ता को GPU की शेष मेमोरी को आवंटित करने का मौका मिले।

CC @chsigg

शायद किसी को यह तभी करना चाहिए जब स्मृति वृद्धि बंद हो। अन्यथा आपको हमेशा 2080 के लिए 580MB की आवश्यकता होगी, भले ही आपको सभी ऑपरेटरों की आवश्यकता न हो।

मैंने अपने परीक्षण मामले से तीन संचालन के संयोजन के लिए न्यूनतम सिस्टम मेमोरी आवश्यकताओं के विषय में कुछ और परीक्षण किए। मैं केवल 1080 और 2080 कार्डों की तुलना करता हूं। आप अकेले conv2d नहीं पाते क्योंकि यह किसी भी मामले में ब्लास को शुरू करता है। बाहर आता है

GPU | MatMul | STFT | Conv2D + MatMUL | MatMul + STFT | MATMUL + STFT + Conv2D |
: --- |: --- |: --- |: --- |: --- |: ---
1080 | 140 एमबी | 130 एमबी | 290 एमबी | 170 एमबी | 320 एमबी
2080 | 190 एमबी | 190 एमबी | 520 एमबी | 250 एमबी | 580 एमबी

कोई यह देख सकता है कि 2080 में क्यूडा को प्रत्येक ऑपरेशन के लिए एक ओवरहेड की आवश्यकता होती है, और अधिक पुस्तकालयों का उपयोग करते समय यह ओवरहेड बढ़ जाता है। ज्यादातर मामलों में ओवरहेड <100MB लेकिन Conv2D शामिल होते ही यह >220MB हो जाता है।

अगर @samhodge ने NVIDIA से संपर्क किया है, तो मैं व्यक्तिगत रूप से यह सुनना दिलचस्प होगा कि क्या यह इरादा है।

सभी को नमस्कार!
मैंने मेमोरी वृद्धि को सीमित करने के साथ इसी तरह की समस्या को हल किया है और आप कोशिश कर सकते हैं।

आप सेक्शन लिमिट मेमोरी ग्रोथ में कोड पा सकते हैं

(यह GitHub में मेरी पहली टिप्पणी है)

मैंने पहले भी इसी तरह का मुद्दा रखा था। GPU मेमोरी को मैन्युअल रूप से सीमित करने में मदद की। https://github.com/tensorflow/tensorflow/issues/25160#issuecomment -643706167

मैं Ubuntu 20.04 पर GeForce RTX 2060 सुपर के साथ एक ही समस्या है। घने परतों के साथ एक एनएन अच्छी तरह से काम करता है। लेकिन CNN परतों के साथ मुझे Failed to get convolution algorithm. This is probably because cuDNN failed to initialize, so try looking to see if a warning log message was printed above.
tf.config.experimental.set_memory_growth(tf.config.list_physical_devices('GPU')[0], True) जोड़ने से त्रुटि पर कोई फर्क नहीं पड़ता।
मैंने https://www.tensorflow.org/install/gpu और nvidia-smi शो के अनुसार स्थापना का पालन किया:
Driver Version: 440.64.00 CUDA Version: 10.2
मेरा कोंडा env है:

cudatoolkit               10.1.243             h6bb024c_0  
cudnn                     7.6.5                cuda10.1_0  
tensorflow-gpu            2.1.0                h0d30ee6_0

1.15 के साथ एक conda env में मुझे वही त्रुटि मिल रही है। यह बहुत अच्छा होगा अगर इसे ठीक किया जा सके।

अपडेट करें

export TF_FORCE_GPU_ALLOW_GROWTH=true का उपयोग करने के बाद यह सब काम करता है। मैं इस धारणा का था कि tf.config.experimental.set_memory_growth(tf.config.list_physical_devices('GPU')[0], True) एक ही चीज़ के लिए होगा, लेकिन ऐसा नहीं है। मुझे लगता है कि इसे TensorFlow GPU सपोर्ट वेबपेज पर स्पष्ट रूप से कहा जाना चाहिए।

यार, तुम्हारा हल मेरी जान बचाता है।

एनवीडिया ने केवल 440.100 और 450.51 (बीटा) लिनक्स डिस्प्ले ड्राइवरों को जारी किया।
मैंने 440.100 की कोशिश की, और इसने समस्या को ठीक नहीं किया। क्या किसी ने बीटा 450.51 की कोशिश की है?

@eduardoscsouza

एनवीडिया ने केवल 440.100 और 450.51 (बीटा) लिनक्स डिस्प्ले ड्राइवरों को जारी किया।
मैंने 440.100 की कोशिश की, और इसने समस्या को ठीक नहीं किया। क्या किसी ने बीटा 450.51 की कोशिश की है?

मैंने 450.36.06 की कोशिश की। https://github.com/tensorflow/tensorflow/issues/25160#issuecomment -643703167 चेक

मेरे लिए काम करने वाला कोड:

tf के रूप में आयात स्पर्शरेखा
config = tf.compat.v1.ConfigProto ()
config.gpu_options.allow_growth = सच
सत्र = tf.compat.v1.InteractiveSession (config = config)

_ कृपया सुनिश्चित करें कि यह एक बग है। हमारी GitHub नीति के अनुसार, हम केवल टैग: Bug_template_

प्रणाली की जानकारी

• क्या मैंने कस्टम कोड लिखा है (TensorFlow में दी गई स्टॉक उदाहरण स्क्रिप्ट का उपयोग करने के विपरीत): हाँ और नहीं (नीचे वर्णित है)
• ओएस प्लेटफॉर्म और वितरण (जैसे, लिनक्स उबंटू 16.04): मंज़रो
• यदि मोबाइल डिवाइस पर समस्या होती है, तो मोबाइल डिवाइस (जैसे iPhone 8, पिक्सेल 2, सैमसंग गैलेक्सी):
• TensorFlow (स्रोत या बाइनरी) से स्थापित: tf-nightly-gpu (दिसम्बर 19, r1.13)
• TensorFlow संस्करण (नीचे कमांड का उपयोग करें): 1.13.0-dev20181219
• पायथन संस्करण: 3.7.1
• Bazel संस्करण (यदि स्रोत से संकलन):
• जीसीसी / संकलक संस्करण (यदि स्रोत से संकलन):
• CUDA / cuDNN संस्करण: CUDA 10 cuDNN 7.4.1 के साथ
• GPU मॉडल और मेमोरी: RTX 2070 8GB

वर्तमान व्यवहार का वर्णन करें
मैं MNN पर CNN मॉडल चला रहा हूं। जब मैं GPU के साथ चल रहा हूं, तो मेरा सामना हो रहा है
2018-12-20 20:09:13.644176: E tensorflow/stream_executor/cuda/cuda_dnn.cc:334] Could not create cudnn handle: CUDNN_STATUS_INTERNAL_ERROR

मैंने कुछ खुदाई की और महसूस किया कि यह एक मेमोरी इश्यू है (जो कि ऐसा नहीं होना चाहिए क्योंकि मेरे पास 32 जीबी की रैम और 64 स्वैप की है। मैं मॉडल चलाते समय htop चला गया और मेरे पास 20 + जीबी मुफ्त है, जो इससे अधिक है 8GB vRAM मैपिंग फिट करने के लिए पर्याप्त है।

gpu_options.allow_growth = True का उपयोग करने से मॉडल ठीक से काम करने लगता है, और os.environ['CUDA_VISIBLE_DEVICES'] = '-1' भी काम करता है। इसका मतलब यह है कि मैं एक स्मृति समस्या का सामना कर रहा हूं, लेकिन मैं यह नहीं देखता कि कैसे।

इसके अलावा, gpu_options.allow_growth = True का उपयोग करते समय समान समस्या को ठीक नहीं किया जाता है जब टेंसरफ़्लो / मॉडल / आधिकारिक / mnist / मॉडल को चलाने की कोशिश की जाती है, जिसमें मेरे कोड के साथ समान व्यवहार होना चाहिए।

समस्या को पुन: उत्पन्न करने के लिए कोड

import os
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import math
import time
# Killing optional CPU driver warnings
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
# os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
tf.logging.set_verbosity(tf.logging.ERROR)


class Model:

    def __init__(self, image, label):
        """
        A Model class contains a computational graph that classifies images
        to predictions. Each of its methods builds part of the graph
        on Model initialization. Do not modify the constructor, as doing so
        would break the autograder. You may, however, add class variables
        to use in your graph-building. e.g. learning rate, 

        image: the input image to the computational graph as a tensor
        label: the correct label of an image as a tensor
        prediction: the output prediction of the computational graph,
                    produced by self.forward_pass()
        optimize: the model's optimizing tensor produced by self.optimizer()
        loss: the model's loss produced by computing self.loss_function()
        accuracy: the model's prediction accuracy
        """
        self.image = image
        self.label = label

        # TO-DO: Add any class variables you want to use.

        self.prediction = self.forward_pass()
        self.loss = self.loss_function()
        self.optimize = self.optimizer()
        self.accuracy = self.accuracy_function()

    def forward_pass(self):
        """
        Predicts a label given an image using convolution layers

        :return: the prediction as a tensor
        """
        filter_1 = tf.Variable(tf.truncated_normal([3, 3, 1, 8], stddev=0.1))
        conv_1 = tf.nn.conv2d(self.image, filter_1, [1, 1, 1, 1], "SAME")

        reshaped = tf.reshape(conv_1, shape=[50, -1])

        L1 = reshaped.shape[1].value
        L2 = 500
        W1 = tf.Variable(tf.random_normal([L1, L2], mean=0, stddev=0.01))
        b1 = tf.Variable(tf.random_normal([L2], mean=0, stddev=0.01))
        relu_1 = tf.nn.relu(tf.matmul(reshaped, W1) + b1)

        W2 = tf.Variable(tf.random_normal([L2, 10], mean=0, stddev=0.01))
        b2 = tf.Variable(tf.random_normal([10], mean=0, stddev=0.01))
        logits = tf.nn.relu(tf.matmul(relu_1, W2) + b2)
        return logits

    def loss_function(self):
        """
        Calculates the model cross-entropy loss

        :return: the loss of the model as a tensor
        """
        loss = tf.losses.softmax_cross_entropy(onehot_labels=self.label, logits=self.prediction)
        return loss

    def optimizer(self):
        """
        Optimizes the model loss using an Adam Optimizer

        :return: the optimizer as a tensor
        """
        learning_rate = 0.1
        sgd = tf.train.GradientDescentOptimizer(learning_rate)
        train = sgd.minimize(self.loss)
        return train

    def accuracy_function(self):
        """
        Calculates the model's prediction accuracy by comparing
        predictions to correct labels – no need to modify this

        :return: the accuracy of the model as a tensor
        """
        correct_prediction = tf.equal(tf.argmax(self.prediction, 1),
                                      tf.argmax(self.label, 1))
        return tf.reduce_mean(tf.cast(correct_prediction, tf.float32))


def main():
    t_start = time.time()

    mnist = input_data.read_data_sets("data/mnist/", one_hot=True)
    batch_sz = 50
    batch = 2000

    inputs = tf.placeholder(shape=[batch_sz, 28, 28, 1], dtype=tf.float32)
    labels = tf.placeholder(shape=[batch_sz, 10], dtype=tf.float32)

    model = Model(inputs, labels)

    session_config = tf.ConfigProto(gpu_options=tf.GPUOptions(allow_growth=True))
    sess = tf.Session(config=session_config)

    # sess = tf.Session()

    sess.run(tf.global_variables_initializer())
    for i in range(batch):
        next_image, next_label = mnist.train.next_batch(batch_sz)
        next_image = next_image.reshape((batch_sz, 28, 28, 1))
        sess.run(model.optimize, feed_dict={inputs: next_image, labels: next_label})

    acc, test_images, test_labels = 0, mnist.test.images, mnist.test.labels
    test_batch = math.ceil(len(test_images) / batch_sz)
    for i in range(test_batch):
        batch_images = test_images[i * batch_sz: (i + 1) * batch_sz]
        batch_images = batch_images.reshape((batch_sz, 28, 28, 1))
        batch_labes = test_labels[i * batch_sz: (i + 1) * batch_sz]
        acc += sess.run(model.accuracy, feed_dict={inputs: batch_images, labels: batch_labes})
    acc /= test_batch
    print(acc)

    print(time.time() - t_start, 'seconds')

    return


if __name__ == '__main__':
    main()

इसने मेरे लिए काम किया।RTX 2060ubuntu 18.04अजगर 3.6

from tensorflow.compat.v1 import ConfigProto
from tensorflow.compat.v1 import InteractiveSession

config = ConfigProto()
config.gpu_options.allow_growth = True
sess = InteractiveSession(config=config)
with sess.as_default():
       process ...

नमस्कार @ bm777

कुछ महीने पहले मेरी जांच के बाद मैं संक्षेप में बताता हूं कि मैं समस्या को कैसे समझता हूं

GPU मॉडल और मेमोरी: RTX 2070 8GB
... जो मामला नहीं होना चाहिए क्योंकि मेरे पास 32GB RAM और 64GB है

समस्या सिस्टम मेमोरी नहीं है, समस्या GPU मेमोरी है!

os.environ ['CUDA_VISIBLE_DEVICES'] = '-1'

काम करता है क्योंकि यह GPU का उपयोग नहीं करता है!

कुछ स्पष्टीकरण:

TF के ऑपरेशन के दो तरीके हैं:

1. allow memory growth = false : इस मामले में TF किसी मोटे अनुमान का उपयोग करते हुए सिस्टम लाइब्रेरी के लिए कुछ मेमोरी का प्रचार करता है
   कितनी मेमोरी चाहिए। के रूप में आप यहां पढ़ सकते हैं https://github.com/tensorflow/tensorflow/issues/24496#issuecomment -+६३,३९,५३,७१५ TF सूत्र का उपयोग करता max(300MB, GPU-MEM * fac) इस अनुमान के लिए। TF2.1 के लिए fac = 0.05 TF2.2 के लिए और यदि मैं
   याद रखें कि यह fac=0.07 । तो अब आपके पास 8GB है जो TF2.1 के तहत GPU पूर्व-आवंटित मेमोरी के लिए 400MB देता है
   और TF2.2.2 के तहत 560MB।

   मैंने प्रायोगिक रूप से कुछ GPU और TF21 के लिए आवश्यक पूर्व-आवंटित मेमोरी का मूल्यांकन यहाँ किया है: https://github.com/tensorflow/tensorflow/issues/24496#issuecomment -637715002 और यहाँ https://github.com/tensorflow/tensorflow / मुद्दों / 24496 # जारी करने -637715002

   Conv2D के संचालन के लिए मुझे वहाँ 520MB की आवश्यकता थी, आपको TF21 से कम लेकिन TF22 के तहत अधिक होगा। दुर्भाग्य से आप अपने TF संस्करण का उल्लेख नहीं करते हैं, लेकिन मुझे लगता है कि आप TF2.1 का उपयोग करते हैं। यदि आप TF2.2 का उपयोग करते हैं और यह अभी भी विफल रहता है, तो हो सकता है कि आप किसी भिन्न GPU का उपयोग करें। वैसे भी तथ्य यह विफल है। निचे देखो

2) allow memory growth = true : TF किसी भी पूर्व-आवंटित मेमोरी का उपयोग नहीं करता है और पुस्तकालयों को लोड करता है जैसे वे आते हैं। TF दस्तावेज़ीकरण में इसे संभावित मेमोरी विखंडन के कारण समस्याग्रस्त घोषित किया गया है और इसलिए डिफ़ॉल्ट रूप से off है।

मेरा स्वीकार कर लेना:

पुस्तकालयों के लिए आवश्यक मेमोरी की बड़ी रेंज को देखते हुए जो आपके द्वारा किए जाने वाले संचालन पर निर्भर करता है और आपके द्वारा GPU पर किया जाता है, यह मोड allow memory growth = false सही मिलना बहुत मुश्किल लगता है (देखें https://github.com/tensorflow/ टेनसफ़्लो / मुद्दे / 24496 # जारीकरण -637950411)। वर्तमान समाधान: पूर्व-आवंटित मेमोरी के आकार को बढ़ाने के लिए, जो TF2.2 के लिए किया गया था, समस्याग्रस्त है अगर आपका GPU छोटा है। यह आपको सभी उपलब्ध पुस्तकालयों (blas, Conv, FFT और मुझे पता नहीं है कि क्या अन्य हैं) की आवश्यकता होगी, यह मानकर उपयोग करने से मेमोरी ब्लॉक हो जाती है। उस स्थिति में जहां आप इन सभी का उपयोग नहीं करते हैं, इसके परिणामस्वरूप पूर्व-आवंटित मेमोरी को बर्बाद करना होगा, बदले में आपके एप्लिकेशन के लिए लोड किए जा सकने वाले मॉडल को कम करना होगा। दूसरी ओर मेरा मानना ​​है कि जब आप प्रशिक्षण शुरू करने से पहले लोड करने के लिए फोर्सिंग सिस्टम लाइब्रेरी को जल्दी मॉडल बनाते हैं तो स्मृति विखंडन की समस्या को रोका जा सकता है। ऐसा लगता है कि वैसे भी ज्यादातर मामलों में क्या हो रहा है और इसलिए यह फायदेमंद लगता है, विशेष रूप से छोटी स्मृति वाले जीपीयू के लिए और विशेष रूप से एकल मॉडल के प्रशिक्षण के लिए, पूर्व-आवंटित नहीं बल्कि allow memory growth = true का उपयोग करने के लिए।

व्यक्तिगत रूप से मैं 4GB से 11GB तक की मेमोरी वाले GPU का उपयोग करता हूं और ऊपर दिए गए तर्क का पालन करते हुए मैंने उन सभी के लिए TF_FORCE_GPU_ALLOW_GROWTH = सही सेट किया है। फिलहाल मुझे इससे कोई समस्या नहीं थी।

नमस्कार @roebel

मुझे भी, मैं स्मृति के आवंटन की त्रुटि के मुद्दों के बारे में सोच रहा था। यह स्पष्ट रूप से मेरे लिए अब है।
अब यह अच्छी GPU मेमोरी लगती है

अतीत में, मैंने मेमोरी को पूर्व-आवंटित करने के लिए कई विकल्पों का परीक्षण किया:

gpus = tf.config.experimental.list_physical_devices('GPU')
try:
    tf.config.experimental.set_virtual_device_configuration(gpus[0], 
                 tf.config.experimental.VirtualDeviceConfiguration(memory_limit=5044)])
    """process...."""
except Exception as e:
    raise e

व्यक्तिगत रूप से मैं 6GB मेमोरी के साथ GPU का उपयोग करता हूं।
और धन्यवाद @roebel , इस नए तीर TF_FORCE_GPU_ALLOW_GROWTH=true लिए मेरे GPU को आवंटन के लिए मजबूर करने के लिए eb ।

मेरा भी यही मुद्दा था। मैं निश्चित रूप से कह सकता हूं कि समस्या केवल मेरे 2070 आरटीएक्स पर होती है, और टाइटन आरटीएक्स पर नहीं, बिल्कुल उसी कोड को चलाने पर।

https://github.com/DeepLabCut/DeepLabCut/issues/837

बस CUDA 11 और cudnn 8.0 के साथ Tensorflow 2.3 में अपग्रेड करें। यह जादुई रूप से मेरी सभी समस्याओं को हल करता है और मुझे config.gpu_options.allow_growth = True साथ वर्कअराउंड की भी आवश्यकता नहीं है।

दुर्भाग्य से, मुझे कोड चलाने की ज़रूरत है जो केवल टेंसरफ़्लो 1.X का समर्थन करता है

बस CUDA 11 और cudnn 8.0 के साथ Tensorflow 2.3 में अपग्रेड करें। यह जादुई रूप से मेरी सभी समस्याओं को हल करता है और मुझे config.gpu_options.allow_growth = True साथ वर्कअराउंड की भी आवश्यकता नहीं है।

2.2 से 2.3 तक के उन्नयन के साथ भी स्पष्ट रूप से TF_FORCE_GPU_ALLOW_GROWTH=false ने मेरे लिए इसे हल कर दिया (कम से कम अब मैं delf डेमो कोड चलाने में सक्षम हूं; कुछ और के साथ परीक्षण नहीं किया गया है)।

मैं अभी भी CUDA 10.1, Cudnn 7.6.5 पर हूं।

वहाँ इस समस्या को 2 और python3 के साथ ठीक करने के लिए तय है ???

मेरे पास एक:
RTX 2080

मुझे यह संदेश मिल रहा है:

2020-08-20 12:38:27.172496: E tensorflow/stream_executor/cuda/cuda_dnn.cc:329] Could not create cudnn handle: CUDNN_STATUS_INTERNAL_ERROR
2020-08-20 12:38:27.177708: E tensorflow/stream_executor/cuda/cuda_dnn.cc:329] Could not create cudnn handle: CUDNN_STATUS_INTERNAL_ERROR
Traceback (most recent call last):
  File "/home/anantha/Desktop/RaspiCar/car.py", line 85, in <module>
    tnet.train(x, y)
  File "/home/anantha/Desktop/RaspiCar/car.py", line 65, in train
    self.model.fit(x, y, epochs=epochs)
  File "/home/anantha/.local/lib/python3.8/site-packages/tensorflow/python/keras/engine/training.py", line 66, in _method_wrapper
    return method(self, *args, **kwargs)
  File "/home/anantha/.local/lib/python3.8/site-packages/tensorflow/python/keras/engine/training.py", line 848, in fit
    tmp_logs = train_function(iterator)
  File "/home/anantha/.local/lib/python3.8/site-packages/tensorflow/python/eager/def_function.py", line 580, in __call__
    result = self._call(*args, **kwds)
  File "/home/anantha/.local/lib/python3.8/site-packages/tensorflow/python/eager/def_function.py", line 644, in _call
    return self._stateless_fn(*args, **kwds)
  File "/home/anantha/.local/lib/python3.8/site-packages/tensorflow/python/eager/function.py", line 2420, in __call__
    return graph_function._filtered_call(args, kwargs)  # pylint: disable=protected-access
  File "/home/anantha/.local/lib/python3.8/site-packages/tensorflow/python/eager/function.py", line 1661, in _filtered_call
    return self._call_flat(
  File "/home/anantha/.local/lib/python3.8/site-packages/tensorflow/python/eager/function.py", line 1745, in _call_flat
    return self._build_call_outputs(self._inference_function.call(
  File "/home/anantha/.local/lib/python3.8/site-packages/tensorflow/python/eager/function.py", line 593, in call
    outputs = execute.execute(
  File "/home/anantha/.local/lib/python3.8/site-packages/tensorflow/python/eager/execute.py", line 59, in quick_execute
    tensors = pywrap_tfe.TFE_Py_Execute(ctx._handle, device_name, op_name,
tensorflow.python.framework.errors_impl.UnknownError:  Failed to get convolution algorithm. This is probably because cuDNN failed to initialize, so try looking to see if a warning log message was printed above.
     [[node sequential/conv2d/Conv2D (defined at /Desktop/RaspiCar/car.py:65) ]] [Op:__inference_train_function_951]

Function call stack:
train_function

यदि आपकी समस्या के मूल में वही समस्याएँ हैं जो वर्तमान समस्या में उपचारित हैं (जो मैं आपकी रिपोर्ट से नहीं जान सकता हूँ) तो कुछ समाधान हैं जो आप पिछले 10-20 पदों को पढ़ने के माध्यम से आसानी से पा सकते हैं धागा।

मैंने इसे इसके साथ तय किया:

config = tf.compat.v1.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.compat.v1.Session(config=config)
sess.as_default()

आरटीएक्स 2080 के साथ मेरा भी यही मुद्दा था। फिर निम्नलिखित कोड ने मेरे लिए काम किया।

from tensorflow.compat.v1 import ConfigProto
from tensorflow.compat.v1 import InteractiveSession

config = ConfigProto()
config.gpu_options.allow_growth = True
session = InteractiveSession(config=config)

सबको धन्यवाद

मुझे लगता है कि अब हम allow_growth फिक्स को पोस्ट करना बंद कर सकते हैं :)

यहाँ RTX 2070। इस त्रुटि को प्राप्त कर रहा था, लेकिन अब TF_FORCE_GPU_ALLOW_GROWTH=true साथ चल रहा है (जैसा कि अन्य टिप्पणीकारों ने बताया है, उनके लिए इसे ठीक करता है) त्रुटि संदेश को मेमोरी त्रुटि से बाहर कर देता है (भले ही मुझे बहुत सी मेमोरी मिली हो):

2020-10-17 16:35:11.717658: I tensorflow/stream_executor/cuda/cuda_driver.cc:831] failed to allocate 3.87G (4159818752 bytes) from device: CUDA_ERROR_OUT_OF_MEMORY: out of memory

लेकिन मेरे GPU में 8GB है और प्रक्रिया शुरू करने से पहले केवल 250MB ही उपयोग में था। तो मुझे समझ में नहीं आता, यह 3.87GB क्यों आवंटित नहीं कर सकता है? (बैच के आकार को कम करने का कोई प्रभाव नहीं था; भार HDf5 फ़ाइल 200MB से कम है)

TF_FORCE_GPU_ALLOW_GROWTH = सच ने मेरे लिए काम किया।
tf.config.experimental.set_memory_growth (gpu, True) ने भी काम किया।

यहाँ मेरा विन्यास है:
GPU GTX 1650
क्यूडा -10-1 10.1.243-1
libcudn7 7.6.5.32-1-1 + cuda10.1
उबंटू 18.04.5 एलटीएस

जो कोई भी पर्यावरण चर को सेट नहीं कर सकता है, वह https://www.tensorflow.org/guide/gpu में सुझाए अनुसार ऐसा कर सकता है:
gpus = tf.config.experimental.list_physical_devices ('GPU')
अगर gpus:
प्रयत्न:
# वर्तमान में, मेमोरी ग्रोथ जीपीयू में समान होना चाहिए
gpus में gpu के लिए:
tf.config.experimental.set_memory_growth (gpu, True)
तार्किक_गपस = tf.config.experimental.list_logical_devices ('GPU')
प्रिंट (len (gpus), "Physical GPUs", len (तार्किक_gpus), "Logical GPU)")
ई के रूप में RuntimeError को छोड़कर:
जीपीयू को इनिशियलाइज़ करने से पहले मेमोरी ग्रोथ सेट करना होगा
प्रिंट (e)

टर्मिनल पर उल्लिखित कमांड टाइप करना मेरे लिए बस काम कर गया।

https://github.com/tensorflow/tfjs/issues/671#issuecomment -494832790

बस CUDA 11 और cudnn 8.0 के साथ Tensorflow 2.3 में अपग्रेड करें। यह जादुई रूप से मेरी सभी समस्याओं को हल करता है और मुझे config.gpu_options.allow_growth = True साथ वर्कअराउंड की भी आवश्यकता नहीं है।

ऐसा लगता है कि इस मुद्दे पर ध्यान दिया जाता है और टेंसरफ़्लो 2.3.0 में हल किया जाता है।

• CUDA 10.1
• GPU: क्वाड्रो RTX 6000
• टेंसरफ्लो 2.2.0
• cudnn 7.6.5

एक ही समस्या है:
tensorflow/stream_executor/cuda/cuda_dnn.cc:328] Could not create cudnn handle: CUDNN_STATUS_INTERNAL_ERROR
tensorflow.python.framework.errors_impl.UnknownError: Failed to get convolution algorithm. This is probably because cuDNN failed to initialize, so try looking to see if a warning log message was printed above.

और वर्कअराउंड allow_growth = True मदद नहीं करता है।

जब मैंने टेंसरफ़्लो को 2.3.0 में अपग्रेड किया, तो लाइन allow_growth = True जोड़ने के बिना भी समस्या गायब हो गई।

ठीक है, इसे tf-nightly-gpu-2.0-प्रीव्यू में काम किया और ipython नोटबुक ने इसे मेरे कोड में जोड़ा:

Tetorflow.compat.v1 इंपोर्ट कॉन्फ़िगरेशनप्रोटो से
Tetorflow.compat.v1 से इंटरएक्टिव सत्र आयात करें

config = configProto ()
config.gpu_options.allow_growth = सच
सत्र = इंटरएक्टिव सत्र (विन्यास = विन्यास)

यह मेरे मामले में काम करता है