लॉगिट्स, सॉफ्टमैक्स और सॉफ्टमैक्स_क्रॉस_एंट्रोपि_विथ_लॉग्स क्या है?

Question

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

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

यदि जो लिखा गया है, logitsवह केवल वही है Tensors, तो एक अलग नाम क्यों रखा गया है logits?

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

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

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

Answer 1

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

tf.nn.softmaxएक इनपुट टेंसर को सॉफ्टमैक्स फ़ंक्शन को लागू करने का सिर्फ परिणाम पैदा करता है । सॉफ्टमैक्स इनपुट को "स्क्वीज़" करता है ताकि sum(input) = 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)

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

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

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

Comments

Softmax_cross_entropy_with_logits के बारे में, मुझे नहीं पता कि क्या मैं इसे सही तरीके से उपयोग करता हूं। परिणाम मेरे कोड में स्थिर नहीं है। समान कोड दो बार चलता है, कुल सटीकता 0.6 से 0.8 तक बदल जाती है। cross_entropy = tf.nn.softmax_cross_entropy_with_logits(tf.nn.softmax(tf.add(tf.matmul(x,W),b)),y) cost=tf.reduce_mean(cross_entropy)। लेकिन जब मैं दूसरे तरीके का उपयोग करता हूं, pred=tf.nn.softmax(tf.add(tf.matmul(x,W),b)) cost =tf.reduce_mean(-tf.reduce_sum(y*tf.log(pred),reduction_indices=1))तो परिणाम स्थिर और बेहतर होता है।

— रिदा

आप अपनी पहली पंक्ति में डबल-सॉफ्टमैक्सिंग कर रहे हैं। softmax_cross_entropy_with_logits बिना किसी लॉग के अपेक्षा करता है, tf.nn.softmax का आउटपुट नहीं। आप सिर्फ tf.nn.softmax_cross_entropy_with_logits(tf.add(tf.matmul(x, W, b))अपने मामले में चाहते हैं ।

— दिगंबर

@ मुझे लगता है कि आपके पास अपने कोड में एक टाइपो है, bब्रैकेट के बाहर होने की जरूरत है,tf.nn.softmax_cross_entropy_with_logits(tf.add(tf.matmul(x, W), b)

— jrieke

क्या करता है कि "इकाइयों को समझने के लिए सापेक्ष पैमाने रैखिक है।" आपके पहले वाक्य का हिस्सा मतलब है?

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

अपवोट-लेकिन आपका उत्तर थोड़ा गलत है जब आप कहते हैं कि "[t] वह एक सॉफ्टमैक्स के आउटपुट का आकार इनपुट के समान है - यह सिर्फ मूल्यों को सामान्य करता है"। सॉफ्टमैक्स मूल्यों को केवल "स्क्वैश" नहीं करता है ताकि उनकी राशि बराबर हो जाए। यह उन्हें पुनर्वितरित भी करता है, और संभवतः इसका मुख्य कारण यह है कि इसका उपयोग क्यों किया जाता है। देखें stackoverflow.com/questions/17187507/... , विशेष रूप से पायोत्र Czapla का जवाब।

— पाओलो पेरोट्टा

Answer 2

लघु संस्करण:

मान लीजिए कि आपके पास दो टेनर्स हैं, y_hatजिसमें प्रत्येक वर्ग के लिए गणना किए गए स्कोर हैं (उदाहरण के लिए, y = W * x + b) और y_trueइसमें एक-हॉट एन्कोडेड ट्रू लेबल शामिल हैं।

y_hat  = ... # Predicted label, e.g. 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.619 है। प्रत्येक प्रशिक्षण उदाहरण के लिए वर्ग की संभावनाएं सामान्यीकृत हैं, इसलिए प्रत्येक पंक्ति का योग 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

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

क्या ये वर्गीकरण सही हैं? हमें प्रशिक्षण सेट से सही लेबल के खिलाफ मापने की आवश्यकता है। आपको एक-गर्म एन्कोडेड y_trueसरणी की आवश्यकता होगी, जहां फिर से पंक्तियाँ प्रशिक्षण उदाहरण हैं और कॉलम कक्षाएं हैं। नीचे मैंने एक उदाहरण 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? हम त्रुटि को मापने के लिए क्रॉस-एन्ट्रापी नुकसान का उपयोग कर सकते हैं ।

हम पंक्ति-वार आधार पर क्रॉस-एन्ट्रापी नुकसान की गणना कर सकते हैं और परिणाम देख सकते हैं। नीचे हम देख सकते हैं कि प्रशिक्षण उदाहरण 1 में 0.479 का नुकसान है, जबकि प्रशिक्षण उदाहरण 2 में 1.200 का अधिक नुकसान है। यह परिणाम समझ में आता है क्योंकि ऊपर दिए गए हमारे उदाहरण में, y_hat_softmaxदिखाया गया है कि प्रशिक्षण उदाहरण 1 की उच्चतम संभावना "कक्षा 2" के लिए थी, जो प्रशिक्षण उदाहरण 1 से मेल खाती है y_true; हालाँकि, प्रशिक्षण उदाहरण 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()फ़ंक्शन का उपयोग करके कुल क्रॉस एन्ट्रापी नुकसान की गणना कर सकते हैं , जैसा कि नीचे दिखाया गया है।

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

Comments

मैं उपरोक्त सभी की पुष्टि करता हूं। सरल कोड: M = tf.random.uniform([100, 10], minval=-1.0, maxval=1.0); labels = tf.one_hot(tf.random.uniform([100], minval=0, maxval=10 , dtype='int32'), 10); tf.nn.softmax_cross_entropy_with_logits(labels=labels, logits=M) - tf.reduce_sum(-tf.nn.log_softmax(M)*tf.one_hot(labels, 10), -1)हर जगह क्लोज-टू-जीरो देता है

— सामी ए। हाइजा

Answer 3

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

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

Logits हैं unnormalized लॉग संभावनाओं उत्पादन मॉडल (softmax सामान्य से पहले मूल्यों उत्पादन उन्हें लागू किया जाता है)।

Comments

मैं समझ गया। फ़ंक्शन को कॉल क्यों नहीं किया जाता है, tf.nn.softmax_cross_entropy_sans_normalization?

— ऑरो

@ यूआरओ क्योंकि यह क्रॉस-एन्ट्रापी गणना के दौरान मूल्यों (आंतरिक रूप से) को सामान्य करता है। इसका tf.nn.softmax_cross_entropy_with_logitsउद्देश्य यह मूल्यांकन करना है कि मॉडल सोने के लेबल से कितना विचलित होता है, सामान्यीकृत आउटपुट प्रदान करने के लिए नहीं।

— erickrf

Tf.nn.sparse_softmax_cross_entropy_with_logits () स्पार्स सॉफ्टमैक्स परत की लागत की गणना करने के मामले में, और इस प्रकार केवल प्रशिक्षण के दौरान उपयोग किया जाना चाहिए कि नए डेटा के खिलाफ मॉडल चलाने पर क्या विकल्प होगा, क्या इस से संभावनाएं प्राप्त करना संभव है। एक।

— सीरियलधिवे

@SerialDev, से संभावनाएँ प्राप्त करना संभव नहीं है tf.nn.sparse_softmax_cross_entropy_with_logits। संभावनाओं का उपयोग करने के लिए tf.nn.softmax।

— नंदेश

Answer 4

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

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

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

Comments

ऊपर दिए गए उत्तर ने प्रश्न को स्पष्ट रूप से नहीं पढ़ा है .. वे सभी वही बातें कहते हैं, जो जानी जाती हैं, लेकिन स्वयं प्रश्न का उत्तर नहीं देते हैं

— Euler_Salter

@abhish क्या आपका मतलब है, tf.nn.softmaxउसके बाद tf.losses.softmax_cross_entropy?

— akurrc

Answer 5

कभी भी softmaxलॉग करने के लिए जाता है, यह वही है जो जे। हिंटन हर समय coursera वीडियो में दोहराता है।

Answer 6

Tensorflow 2.0 संगत जवाब : के स्पष्टीकरण dgaऔर stackoverflowuser2010लॉगिट्स और संबंधित कार्यों के बारे में बहुत विस्तृत हैं।

उन सभी कार्यों, जब में इस्तेमाल Tensorflow 1.xइच्छा काम ठीक है, लेकिन अगर आप अपने कोड की ओर पलायन 1.x (1.14, 1.15, etc)करने के लिए 2.x (2.0, 2.1, etc..), उन कार्यों का उपयोग कर त्रुटि हो।

इसलिए, सभी कार्यों के लिए 2.0 संगत कॉल को निर्दिष्ट करते हुए, हमने ऊपर चर्चा की, अगर हम 1.x to 2.xसमुदाय के लाभ के लिए प्रवास करते हैं।

1.x में कार्य :

1. tf.nn.softmax
2. tf.nn.softmax_cross_entropy_with_logits
3. tf.nn.sparse_softmax_cross_entropy_with_logits

1.x से 2.x पर माइग्रेट होने पर प्रतिक्रियाशील कार्य :

1. tf.compat.v2.nn.softmax
2. tf.compat.v2.nn.softmax_cross_entropy_with_logits
3. tf.compat.v2.nn.sparse_softmax_cross_entropy_with_logits

1.x से 2.x पर माइग्रेशन के बारे में अधिक जानकारी के लिए, कृपया इस माइग्रेशन गाइड को देखें ।

Answer 7

एक और बात जो मैं निश्चित रूप से उजागर करना चाहूंगा क्योंकि लॉजिट एक कच्चा उत्पादन है, आम तौर पर अंतिम परत का उत्पादन। यह एक नकारात्मक मूल्य भी हो सकता है। यदि हम इसे "क्रॉस एन्ट्रॉपी" मूल्यांकन के लिए उपयोग करते हैं जैसा कि नीचे उल्लेख किया गया है:

-tf.reduce_sum(y_true * tf.log(logits))

तब यह काम नहीं करेगा। के रूप में लॉग के -ve परिभाषित नहीं है। तो ओ सॉफ्टमैक्स सक्रियण का उपयोग करके, इस समस्या को दूर करेगा।

यह मेरी समझ है, अगर गलत है तो कृपया मुझे सही करें।