दिलचस्प पोस्ट
आप मेमोरीस्ट्रीम से स्ट्रिंग कैसे प्राप्त करते हैं? JQuery डेटा () एपीआई का उपयोग करते हुए डेटा विशेषता को सेट करने में असमर्थ क्या एएसपी.नेट में एक अनुरोध या एक सर्वर के लिए स्थिर वर्ग के उदाहरण हैं? FileInputStream बनाम FileReader वेब टेक्स्ट को कॉपी करने के लिए अतिरिक्त जानकारी कैसे जोड़ें XPath परीक्षण अगर नोड मान संख्या है C ++ में निजी फ़ंक्शन के साथ सार्वजनिक वर्चुअल फ़ंक्शन को ओवरराइड करना Geom_bar ggplot2 में बार पुन: व्यवस्थित करें उपयोगकर्ता-निर्दिष्ट रूट निर्देशिका में उप-फ़ोल्डरों और फ़ाइलों के माध्यम से साइकिल स्विफ्ट के साथ स्ट्रिंग में एक सबस्ट्रिंग का सूचकांक PHP file_get_contents () और सेटिंग हेडर सेट करना पहेली गेम में जेपीनेल अपडेट नहीं कर रहा है बाश में $ PATH चर में पथ को हटाने का सबसे शानदार तरीका क्या है? क्रम के साथ रेल 4 के लिए अपवितरित चेतावनी लॉगिन बटन के बिना फेसबुक प्रमाणीकरण

tensorflow tf.nn.softmax और tf.nn.softmax_cross_entropy_with_logits के बीच का अंतर

मैं टेनसर्फ्लो एपीआई डॉक्स के माध्यम से जा रहा था। Tensorflow दस्तावेज़ में वे एक खोजशब्द बुलाया नामक इस्तेमाल किया यह क्या है? एपीआई डॉक्स में कई तरीकों से लिखा गया है,

tf.nn.softmax(logits, name=None)

अब जो लिखा है वह यह है कि logits केवल logits हैं अच्छा क्यों logits तरह एक अलग नाम रखना? मैंने लगभग सोचा कि यह logics था :D

एक और बात यह है कि दो तरीके हैं जो मैं अंतर नहीं कर सका। वो थे

 tf.nn.softmax(logits, name=None) tf.nn.softmax_cross_entropy_with_logits(logits, labels, name=None) 

उन दोनों के बीच अंतर क्या है? डॉक्स मेरे लिए स्पष्ट नहीं हैं मुझे पता है क्या tf.nn.softmax करता है लेकिन अन्य नहीं एक उदाहरण वास्तव में मददगार होगा

वेब के समाधान से एकत्रित समाधान "tensorflow tf.nn.softmax और tf.nn.softmax_cross_entropy_with_logits के बीच का अंतर"

लॉग्स का अर्थ केवल इसका मतलब है कि फ़ंक्शन पहले की परतों के अनकेल आउटपुट पर कार्य करता है और यह कि यूनिट्स को समझने के लिए सापेक्ष स्केल रैखिक है। इसका अर्थ है, विशेष रूप से, निविष्टियों का योग 1 के बराबर नहीं हो सकता है, यह मान संभावनाएं नहीं हैं (आपके पास 5 का इनपुट हो सकता है)।

tf.nn.softmax एक इनपुट tensor करने के लिए softmax फंक्शन लागू करने का सिर्फ परिणाम पैदा करता है। सॉफ्टमॅक्स इनपुट को "स्क्वीज़ करता है" ताकि राशि (इनपुट) = 1; यह सामान्य करने का एक तरीका है सॉफ्टमैक्स के आउटपुट का आकार इनपुट के समान है – यह केवल मानों को सामान्य बनाता है सॉफ्टमॅक्स के आउटपुट्स को संभाव्यता के रूप में व्याख्या किया जा सकता है

 a = tf.constant(np.array([[.1, .3, .5, .9]])) print s.run(tf.nn.softmax(a)) [[ 0.16838508 0.205666 0.25120102 0.37474789]] 

इसके विपरीत, tf.nn.softmax_cross_entropy_with_logits सॉफ्टमॅक्स फ़ंक्शन लागू करने के बाद परिणाम के क्रॉस एन्ट्रापी की गणना करता है (लेकिन यह सभी एक साथ अधिक गणितीय रूप से सावधानीपूर्वक तरीके से करता है)। यह के परिणाम के समान है:

 sm = tf.nn.softmax(x) ce = cross_entropy(sm) 

क्रॉस एन्ट्रापी एक सार मीट्रिक है – यह सभी तत्वों के बीच की राशि है एक आकार [2,5] टेंसर पर tf.nn.softmax_cross_entropy_with_logits आकृति आकार [2,5] tf.nn.softmax_cross_entropy_with_logits [2,1] (पहला आयाम बैच के रूप में माना जाता है) का है।

यदि आप क्रॉस एन्ट्रापी को कम करने के लिए ऑप्टिमाइज़ेशन करना चाहते हैं, और आप अपनी पिछली परत के बाद सॉफ्टमॅक्सिंग कर रहे हैं, तो आपको इसे स्वयं करने के बजाय tf.nn.softmax_cross_entropy_with_logits उपयोग करना चाहिए, क्योंकि यह गणितीय सही तरीके से संख्यात्मक अस्थिर कोने के मामलों को शामिल करता है। अन्यथा, आप यहां और वहां थोड़ा एपिसलॉन जोड़कर इसे हैकिंग कर देंगे।

(संपादित 2016-02-07: यदि आपके पास सिंगल-क्लास लेबल्स हैं, जहां एक ऑब्जेक्ट केवल एक क्लास से संबंधित हो, तो आप अब tf.nn.sparse_softmax_cross_entropy_with_logits का उपयोग करने पर विचार कर सकते हैं ताकि आपको अपने लेबल को घने में परिवर्तित नहीं करना पड़े। एक-गर्म सरणी। इस फ़ंक्शन को रिलीज़ 0.6.0 के बाद जोड़ा गया था।)

लघु संस्करण:

मान लें कि आपके पास दो tensors हैं, जहां y_hat प्रत्येक वर्ग के लिए गणना संख्या (उदाहरण के लिए, y = w * x + b) और y_true में एक-गर्म एन्कोडेड सच लेबल शामिल हैं

 y_hat = ... # Predicted label, eg y = tf.matmul(X, W) + b y_true = ... # True label, one-hot encoded 

यदि आप असामान्य लॉग संभाव्यताओं के रूप में y_hat में स्कोर की व्याख्या करते हैं, तो वे लॉग-इन हैं

इसके अतिरिक्त, इस तरह से कुल क्रॉस-एंट्रपी हानि की गणना की गई है:

 y_hat_softmax = tf.nn.softmax(y_hat) total_loss = tf.reduce_mean(-tf.reduce_sum(y_true * tf.log(y_hat_softmax), [1])) 

फ़ंक्शन softmax_cross_entropy_with_logits() साथ गणना की गई कुल क्रॉस-एंट्रोपी हानि के बराबर है:

 total_loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(y_hat, y_true)) 

दीर्घ संस्करण:

आपके तंत्रिका नेटवर्क की आउटपुट परत में, आप शायद एक सरणी की गणना करेंगे जिसमें आपके प्रत्येक प्रशिक्षण उदाहरणों के लिए वर्ग स्कोर होंगे, जैसे कि गणना y_hat = W*x + b एक उदाहरण के रूप में सेवा करने के लिए, नीचे मैंने एक y_hat को 2 x 3 सरणी के रूप में बनाया है, जहां पंक्तियां प्रशिक्षण के उदाहरणों के अनुरूप होती हैं और कॉलम कक्षाओं के अनुरूप होते हैं। तो यहाँ 2 प्रशिक्षण उदाहरण और 3 कक्षाएं हैं।

 import tensorflow as tf import numpy as np sess = tf.Session() # Create example y_hat. y_hat = tf.convert_to_tensor(np.array([[0.5, 1.5, 0.1],[2.2, 1.3, 1.7]])) sess.run(y_hat) # array([[ 0.5, 1.5, 0.1], # [ 2.2, 1.3, 1.7]]) 

ध्यान दें कि मान सामान्यीकृत नहीं हैं (अर्थात पंक्ति 1 से जोड़ नहीं सकते हैं) उन्हें सामान्य करने के लिए, हम सॉफ्टमॅक्स फ़ंक्शन को लागू कर सकते हैं, जो इनपुट को असामान्य लॉग संभाव्यताओं (उर्फ लॉग्स ) के रूप में व्याख्या करता है और सामान्यीकृत रैखिक संभावनाओं को आउटपुट करता है

 y_hat_softmax = tf.nn.softmax(y_hat) sess.run(y_hat_softmax) # array([[ 0.227863 , 0.61939586, 0.15274114], # [ 0.49674623, 0.20196195, 0.30129182]]) 

सॉफ्टमैक्स आउटपुट क्या कह रहा है यह पूरी तरह समझना महत्वपूर्ण है। नीचे मैंने एक तालिका दिखायी है जो ऊपर दिए गए आउटपुट का अधिक स्पष्ट रूप से प्रतिनिधित्व करती है। यह देखा जा सकता है कि, उदाहरण के लिए, प्रशिक्षण उदाहरण 1 की "कक्षा 2" की संभावना 0.6 1 9 है। प्रत्येक प्रशिक्षण आवृत्ति के लिए वर्ग संभावनाएं सामान्यीकृत हैं, इसलिए प्रत्येक पंक्ति का योग 1.0 है।

  Pr(Class 1) Pr(Class 2) Pr(Class 3) ,-------------------------------------- Training instance 1 | 0.227863 | 0.61939586 | 0.15274114 Training instance 2 | 0.49674623 | 0.20196195 | 0.30129182 

तो अब हमारे पास प्रत्येक प्रशिक्षण आवृत्ति के लिए क्लास की संभाव्यता है, जहां अंतिम श्रेणीकरण उत्पन्न करने के लिए हम प्रत्येक पंक्ति के एग्रीमैक्स () ले सकते हैं। उपर्युक्त से, हम उस प्रशिक्षण उदाहरण 1 को "कक्षा 2" से संबंधित कर सकते हैं और प्रशिक्षण उदाहरण 2 "कक्षा 1" से संबंधित है।

क्या ये वर्गीकरण सही हैं? हमें प्रशिक्षण सेटों से सही लेबल्स के खिलाफ मापने की जरूरत है। आपको एक गर्म एन्कोडेड y_true array की आवश्यकता होगी, जहां पंक्तियों को प्रशिक्षण उदाहरण और कॉलम कक्षाएं हैं। नीचे मैंने एक उदाहरण y_true एक-गर्म सरणी बनाया है जहां प्रशिक्षण उदाहरण 1 के लिए सही लेबल "कक्षा 2" है और प्रशिक्षण उदाहरण 2 के लिए सही लेबल "वर्ग 3" है

 y_true = tf.convert_to_tensor(np.array([[0.0, 1.0, 0.0],[0.0, 0.0, 1.0]])) sess.run(y_true) # array([[ 0., 1., 0.], # [ 0., 0., 1.]]) 

क्या y_hat_softmax में संभावना वितरण वितरण y_true में संभावना वितरण के y_true ? हम त्रुटि को मापने के लिए क्रॉस-एंट्रोपी हानि का उपयोग कर सकते हैं।

क्रॉस-एंट्रोपी हानि के लिए फॉर्मूला

हम पंक्ति-वार आधार पर क्रॉस-एन्ट्रापी हानि की गणना कर सकते हैं और परिणाम देख सकते हैं। नीचे हम देख सकते हैं कि प्रशिक्षण उदाहरण 1 में 0.479 का नुकसान है, जबकि प्रशिक्षण के उदाहरण 2 में 1.200 का उच्च घाटा है। यह परिणाम समझ में आता है क्योंकि ऊपर दिए गए हमारे उदाहरण में, y_hat_softmax ने दिखाया कि प्रशिक्षण उदाहरण 1 की सबसे अधिक संभावना "कक्षा 2" के लिए थी, जो y_true में प्रशिक्षण उदाहरण 1 से मेल खाता है; हालांकि, प्रशिक्षण उदाहरण 2 के लिए भविष्यवाणी "कक्षा 1" के लिए सबसे अधिक संभावना दिखाती है, जो सही वर्ग "कक्षा 3" से मेल नहीं खाता है।

 loss_per_instance_1 = -tf.reduce_sum(y_true * tf.log(y_hat_softmax), reduction_indices=[1]) sess.run(loss_per_instance_1) # array([ 0.4790107 , 1.19967598]) 

हम वास्तव में चाहते हैं कि सभी प्रशिक्षण मामलों पर कुल नुकसान हो। तो हम गणना कर सकते हैं:

 total_loss_1 = tf.reduce_mean(-tf.reduce_sum(y_true * tf.log(y_hat_softmax), reduction_indices=[1])) sess.run(total_loss_1) # 0.83934333897877944 

Softmax_cross_entropy_with_logits का उपयोग करना ()

इसके बजाय हम नीचे कुल दिखाए अनुसार, कुल क्रॉस एंट्रोपी हानि को tf.nn.softmax_cross_entropy_with_logits() फ़ंक्शन का उपयोग कर tf.nn.softmax_cross_entropy_with_logits() हैं।

 loss_per_instance_2 = tf.nn.softmax_cross_entropy_with_logits(y_hat, y_true) sess.run(loss_per_instance_2) # array([ 0.4790107 , 1.19967598]) total_loss_2 = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(y_hat, y_true)) sess.run(total_loss_2) # 0.83934333897877922 

ध्यान दें कि total_loss_1 और total_loss_2 बहुत अंतिम अंकों में कुछ छोटे अंतर के साथ अनिवार्य रूप से समतुल्य परिणाम का उत्पादन करते हैं। हालांकि, आप दूसरे दृष्टिकोण का उपयोग भी कर सकते हैं: यह एक कम पंक्ति की कोड लेता है और कम संख्यात्मक त्रुटि जमा करता है क्योंकि सॉफ्टमैक्स आपके लिए softmax_cross_entropy_with_logits() अंदर किया जाता है

tf.nn.softmax एक सॉफ्टमैक्स परत के माध्यम से आगे के प्रसार की गणना करता है। आप मॉडल के मूल्यांकन के दौरान इसका उपयोग करते हैं जब आप संभाव्यताओं की गणना करते हैं जो कि मॉडल आउटपुट है।

tf.nn.softmax_cross_entropy_with_logits एक सॉफ्टमैक्स परत के लिए लागत की गणना करता है। यह केवल प्रशिक्षण के दौरान प्रयोग किया जाता है

लॉग्स असामान्य लॉग संभाव्यता मॉडल को आउटपुट करती हैं (सॉफ्टमैक्स सामान्यीकरण से पहले मूल्यों का उत्पादन उन पर लागू होता है)।

उत्तर के उत्तर में पूछे जाने वाले प्रश्न के लिए पर्याप्त विवरण है।

उसमें जोड़कर, टेन्सफोल्व ने सक्रियण फ़ंक्शन को लागू करने के ऑपरेशन को अनुकूलित किया है, फिर लागत कार्यों के बाद अपने स्वयं के सक्रियण का उपयोग करके लागत की गणना कर रहा है। इसलिए यह उपयोग करने के लिए एक अच्छा अभ्यास है: tf.nn.softmax_cross_entropy() पर tf.nn.softmax(); tf.nn.cross_entropy() tf.nn.softmax(); tf.nn.cross_entropy()

आप उनके बीच एक संसाधन गहन मॉडल में प्रमुख अंतर पा सकते हैं।