दिलचस्प पोस्ट
एक जेएसओएन स्ट्रिंग लेते हुए, उसे एक नक्शा इंटरफ़ेस {}, संपादन, और इसे बाइट में मार्शल करने में असमर्थ बनाते हुए अधिक जटिल लगता है तो यह होना चाहिए Android पर सूची दृश्य के शीर्ष पर नई आइटम जोड़ें? फ़ायरफ़ॉक्स -मोझ-सीमा-त्रिज्या छवि को क्रॉप नहीं करेगा? जूडाटाइम के साथ किसी विशेष महीने की आखिरी तारीख कैसे प्राप्त करें? जेफ्री चार्ट बारचार्ट -> नो ग्रेडिएंट लिबोजपेग संकलित करना एक सरल फ़ाइल डाउनलोड सर्वलेट को लागू करना Window.close और क्रोम के साथ समस्या सेट इन्टेरॉल के पायथन समरूप ()? FileSystemWatcher बनाम मतदान में परिवर्तन के लिए देखने के लिए प्रोल में शफल करें 404 लौटने के बिना एक ऑब्जेक्ट डीजेंगो दृश्य में मौजूद होने पर मान्य करने का सही तरीका क्या है? UISwipeGestureRecognizer स्वाइप लंबाई जावा एसएसएल और प्रमाणपत्र कीस्टस्टोर java.lang.IllegalStateException: एफएक्स आवेदन थ्रेड पर नहीं; currentThread = थ्रेड -4

Tensorflow नाएन बग?

मैं TensorFlow का उपयोग कर रहा हूँ और मैं अपनी आरजीबी छवियों को लेने के लिए ट्यूटोरियल उदाहरण को संशोधित किया।

एल्गोरिथ्म, नई छवि सेट पर बॉक्स से बाहर निकलकर काम करता है, जब तक कि अचानक (अभी भी सम्मिलित होना, यह लगभग 9 2% सटीकता है), यह त्रुटि के साथ दुर्घटनाग्रस्त हो जाता है कि ReluGrad को गैर- डिबगिंग से पता चलता है कि अनगिनत कारणों के लिए संख्याओं के साथ कुछ भी असंभव नहीं होता है, अज्ञात कारण के लिए, त्रुटि को फेंक दिया जाता है। जोड़ा जा रहा है

print "max W vales: %g %g %g %g"%(tf.reduce_max(tf.abs(W_conv1)).eval(),tf.reduce_max(tf.abs(W_conv2)).eval(),tf.reduce_max(tf.abs(W_fc1)).eval(),tf.reduce_max(tf.abs(W_fc2)).eval()) print "max b vales: %g %g %g %g"%(tf.reduce_max(tf.abs(b_conv1)).eval(),tf.reduce_max(tf.abs(b_conv2)).eval(),tf.reduce_max(tf.abs(b_fc1)).eval(),tf.reduce_max(tf.abs(b_fc2)).eval()) 

प्रत्येक लूप में डिबग कोड के रूप में, निम्न आउटपुट प्राप्त करता है:

 Step 8600 max W vales: 0.759422 0.295087 0.344725 0.583884 max b vales: 0.110509 0.111748 0.115327 0.124324 Step 8601 max W vales: 0.75947 0.295084 0.344723 0.583893 max b vales: 0.110516 0.111753 0.115322 0.124332 Step 8602 max W vales: 0.759521 0.295101 0.34472 0.5839 max b vales: 0.110521 0.111747 0.115312 0.124365 Step 8603 max W vales: -3.40282e+38 -3.40282e+38 -3.40282e+38 -3.40282e+38 max b vales: -3.40282e+38 -3.40282e+38 -3.40282e+38 -3.40282e+38 

मेरे मूल्यों में से कोई भी बहुत अधिक नहीं है, इसलिए एक नाएन का एकमात्र तरीका बुरी तरह से संभाला 0/0 से हो सकता है, लेकिन जब से यह ट्यूटोरियल कोड किसी भी डिवीजन या समान ऑपरेशन नहीं करता, तब से मुझे कोई अन्य स्पष्टीकरण नहीं मिल रहा है आंतरिक टीएफ कोड

मुझे इस बारे में पता नहीं है कि इसके साथ क्या करना है कोई सुझाव? एल्गोरिथ्म अच्छी तरह से सम्मिलित हो रहा है, मेरी मान्यता सेट पर इसकी सटीकता तेजी से बढ़ रही है और इसे फिर से 8600 पर 92.5% तक पहुंच गया।

Solutions Collecting From Web of "Tensorflow नाएन बग?"

असल में, यह कुछ बेवकूफ हो गया मैं इसे पोस्ट कर रहा हूं अगर किसी और को भी इसी तरह की त्रुटि मिल जाएगी।

 cross_entropy = -tf.reduce_sum(y_*tf.log(y_conv)) 

वास्तव में क्रॉस-एन्ट्रापी की गणना करने का एक भयानक तरीका है कुछ नमूनों में कुछ समय के बाद कुछ वर्गों को निश्चितता से बाहर रखा जा सकता है, जिसके परिणामस्वरूप उस नमूने के लिए y_conv = 0 हो सकता है। यह आम तौर पर एक समस्या नहीं है क्योंकि आप उन में दिलचस्पी नहीं रखते हैं, लेकिन जिस तरह से क्रॉस_ंट्रॉपी वहां लिखी गई है, उसमें उस विशेष नमूना / वर्ग के लिए 0 * लॉग (0) पैदा होती है इसलिए नाएन

इसके साथ बदलकर

 cross_entropy = -tf.reduce_sum(y_*tf.log(tf.clip_by_value(y_conv,1e-10,1.0))) 

मेरी सभी समस्याओं का हल

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

 cross_entropy = -tf.reduce_sum(y_*tf.log(y_conv + 1e-10)) 

अगर y_conv एक सॉफ्टमैक्स का परिणाम है, तो कहते हैं, y_conv = tf.nn.softmax(x) , फिर एक बेहतर समाधान यह log_softmax साथ log_softmax :

 y = tf.nn.log_softmax(x) cross_entropy = -tf.reduce_sum(y_*y) 

पूर्वाग्रह मुक्त विकल्प

अन्य कई समाधान एक अनिर्धारित ढाल से बचने के लिए कतरन का उपयोग करते हैं। आपकी समस्या के आधार पर, क्लिपिंग पूर्वाग्रह का परिचय देती है और सभी मामलों में स्वीकार्य नहीं हो सकती है। जैसा कि निम्नलिखित कोड दर्शाता है, हमें केवल असंतुलन के बिंदु को संभालना है – इसके पास क्षेत्र नहीं है

विशिष्ट उत्तर

 def cross_entropy(x, y, axis=-1): safe_y = tf.where(tf.equal(x, 0.), tf.ones_like(y), y) return -tf.reduce_sum(x * tf.log(safe_y), axis) def entropy(x, axis=-1): return cross_entropy(x, x, axis) 

लेकिन क्या यह काम करता है?

 x = tf.constant([0.1, 0.2, 0., 0.7]) e = entropy(x) # ==> 0.80181855 g = tf.gradients(e, x)[0] # ==> array([1.30258512, 0.60943794, 0., -0.64332503], dtype=float32) Yay! No NaN. 

(नोट: हटाए गए डॉप क्रॉस-पोस्ट ।)

सामान्य नुस्खा

एक आंतरिक tf.where का उपयोग करें ताकि यह सुनिश्चित हो सके कि समारोह में कोई एसिम्प्टोट नहीं है। अर्थात्, जनसंपर्क पैदा करने के लिए ऐसे इनपुट को परिवर्तित करना जैसे कि कोई भी आईएनजी बनाया नहीं जा सकता। फिर एक दूसरे tf.where का उपयोग करें ताकि हमेशा मान्य कोड-पथ का चयन करें। यही है, गणितीय स्थिति को कार्यान्वित करें जैसा कि आप "सामान्य रूप से" करेंगे, अर्थात् "अनुभवहीन" कार्यान्वयन।

पायथन कोड में, नुस्खा है:

इसके अलावा:

 tf.where(x_ok, f(x), safe_f(x)) 

यह करो:

 safe_x = tf.where(x_ok, x, safe_x) tf.where(x_ok, f(safe_x), safe_f(x)) 

उदाहरण

मान लीजिए आप गणना करना चाहते हैं:

 f(x) = { 1/x, x!=0 { 0, x=0 

ढाल में एनएएन में एक भोले-भरे क्रियान्वयन परिणाम, अर्थात्,

 def f(x): x_ok = tf.not_equal(x, 0.) f = lambda x: 1. / x safe_f = tf.zeros_like return tf.where(x_ok, f(x), safe_f(x)) 

क्या यह काम करता है?

 x = tf.constant([-1., 0, 1]) tf.gradients(f(x), x)[0].eval() # ==> array([ -1., nan, -1.], dtype=float32) # ...bah! We have a NaN at the asymptote despite not having # an asymptote in the non-differentiated result. 

tf.where का उपयोग करते समय NaN tf.where से बचने के लिए मूल रूप से tf.where दो बार कॉल tf.where अंदरूनी tf.where सुनिश्चित करता है कि परिणाम f(x) हमेशा सीमित है। tf.where सुनिश्चित करता है कि सही परिणाम चुना जाता है। चल रहे उदाहरण के लिए, चाल इस तरह खेलती है:

 def safe_f(x): x_ok = tf.not_equal(x, 0.) f = lambda x: 1. / x safe_f = tf.zeros_like safe_x = tf.where(x_ok, x, tf.ones_like(x)) return tf.where(x_ok, f(safe_x), safe_f(x)) 

लेकिन क्या यह काम करता है?

 x = tf.constant([-1., 0, 1]) tf.gradients(safe_f(x), x)[0].eval() # ==> array([-1., 0., -1.], dtype=float32) # ...yay! double-where trick worked. Notice that the gradient # is now a constant at the asymptote (as opposed to being NaN). 

आप मानक सूत्र का उपयोग कर क्रॉस-एन्ट्रॉपी की गणना करने का प्रयास कर रहे हैं। न केवल मान अनिर्धारित है जब x=0 , यह संख्यात्मक रूप से अस्थिर भी है।

यह बेहतर है tf.nn.softmax_cross_entropy_with_logits का उपयोग करें या यदि आप वास्तव में लॉग में बहुत छोटी संख्या के लिए tf.clip_by_value zeros के लिए हाथ से तैयार की जाती फार्मूला का उपयोग करना चाहते हैं।

यहां द्विआधारी (सिग्मोयॉइड) के कार्यान्वयन और TensorFlow 1.1 में स्पष्ट (सॉफ्टमॅक्स) क्रॉस-एंट्रोपी नुकसान है:

चूंकि किसी को द्विआधारी मामले में देखा जा सकता है, इसलिए वे कुछ विशेष मामलों को संख्यात्मक स्थिरता प्राप्त करने के लिए मानते हैं:

 # The logistic loss formula from above is # x - x * z + log(1 + exp(-x)) # For x < 0, a more numerically stable formula is # -x * z + log(1 + exp(x)) # Note that these two expressions can be combined into the following: # max(x, 0) - x * z + log(1 + exp(-abs(x))) # To allow computing gradients at zero, we define custom versions of max and # abs functions. zeros = array_ops.zeros_like(logits, dtype=logits.dtype) cond = (logits >= zeros) relu_logits = array_ops.where(cond, logits, zeros) neg_abs_logits = array_ops.where(cond, -logits, logits) return math_ops.add(relu_logits - logits * labels, math_ops.log1p(math_ops.exp(neg_abs_logits)), name=name)