तंत्रिका नेटवर्क: किस लागत का उपयोग करना है?

Question

मैं मुख्य रूप से तंत्रिका नेटवर्क के साथ प्रयोगों के लिए TensorFlow का उपयोग कर रहा हूं । हालाँकि मैंने अभी कुछ प्रयोग किए हैं (XOR- प्रॉब्लम, MNIST, कुछ रिग्रेशन स्टफ, ...) अब, मैं विशिष्ट समस्याओं के लिए "सही" लागत फ़ंक्शन चुनने के साथ संघर्ष करता हूं क्योंकि कुल मिलाकर मुझे एक शुरुआत माना जा सकता है।

TensorFlow में आने से पहले मैंने कुछ पूर्ण-कनेक्ट किए गए MLP और कुछ आवर्ती नेटवर्क को अपने आप से Python और NumPy के साथ कोडित किया था, लेकिन ज्यादातर मुझे ऐसी समस्याएं थीं जहां एक साधारण चुकता त्रुटि और एक साधारण ढाल des पर्याप्त थी।

हालाँकि, चूंकि TensorFlow काफी लागत कार्यों के साथ-साथ कस्टम कॉस्ट फ़ंक्शंस के निर्माण की पेशकश करता है, इसलिए मैं जानना चाहूंगा कि क्या विशेष रूप से तंत्रिका नेटवर्क पर लागत कार्यों के लिए किसी प्रकार का ट्यूटोरियल है? (मैंने पहले ही आधिकारिक TensorFlow ट्यूटोरियल के आधे हिस्से की तरह काम किया है, लेकिन वे वास्तव में यह नहीं बता रहे हैं कि विशिष्ट समस्याओं के लिए विशिष्ट लागत कार्यों या शिक्षार्थियों का उपयोग क्यों किया जाता है - कम से कम शुरुआती के लिए नहीं)

कुछ उदाहरण देने के लिए:

cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(y_output, y_train))

मुझे लगता है कि यह दोनों इनपुट पर सॉफ्टमैक्स फ़ंक्शन को लागू करता है ताकि एक वेक्टर का योग 1 के बराबर हो। लेकिन लॉग के साथ वास्तव में क्रॉस एन्ट्रॉपी क्या है? मैंने सोचा था कि यह मूल्यों को बोता है और क्रॉस एन्ट्रॉपी की गणना करता है ... इसलिए कुछ मीट्रिक माप ?! क्या यह बहुत ज्यादा नहीं होगा यदि मैं आउटपुट को सामान्य करता हूं, इसे योग करता हूं और चुकता त्रुटि लेता हूं? इसके अतिरिक्त, MNIST (या बहुत कठिन समस्याओं) के लिए इसका उपयोग क्यों किया जाता है? जब मैं 10 या शायद 1000 वर्गों की तरह वर्गीकृत करना चाहता हूं, तो उन मूल्यों को पूरी तरह से समेटना नहीं है जो वास्तव में किस वर्ग के आउटपुट के बारे में जानकारी को नष्ट कर देते हैं ?

cost = tf.nn.l2_loss(vector)

यह किस लिए है? मैंने सोचा था कि एल 2 नुकसान बहुत अधिक चुकता त्रुटि है, लेकिन टेंसोरफ्लो का एपीआई बताता है कि यह इनपुट सिर्फ एक टेंसर है। विचार बिल्कुल नहीं मिलता है ?!

इसके अलावा मैंने इसे क्रॉस एन्ट्रॉपी के लिए बहुत बार देखा:

cross_entropy = -tf.reduce_sum(y_train * tf.log(y_output))

... लेकिन इसका उपयोग क्यों किया जाता है? क्रॉस एन्ट्रापी में नुकसान गणितीय रूप से यह नहीं है:

-1/n * sum(y_train * log(y_output) + (1 - y_train) * log(1 - y_output))

(1 - y_train) * log(1 - y_output)अधिकांश TensorFlow उदाहरणों में भाग कहाँ है ? क्या यह याद नहीं है?

---

उत्तर: मुझे पता है कि यह प्रश्न काफी खुला है, लेकिन मुझे विस्तार से सूचीबद्ध हर एक समस्या / लागत फ़ंक्शन के साथ 10 पृष्ठों की तरह मिलने की उम्मीद नहीं है। मुझे केवल इस बात के बारे में एक संक्षिप्त सारांश की आवश्यकता है कि किस लागत फ़ंक्शन का उपयोग करना है (सामान्य रूप से या टेन्सरफ्लो में, मेरे लिए बहुत मायने नहीं रखता) और इस विषय के बारे में कुछ स्पष्टीकरण। और / या कुछ स्रोत (शुरुआती) के लिए;)

Comments

अच्छा प्रश्न। साइट के लिए :) आपका स्वागत है

— Dawny33

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

— मार्टिन थोमा

मुझे लगता है कि कम_सुम (y_train * tf.log (y_output)) का उपयोग बहुत किया जाता है क्योंकि इसका एक सामान्य "साधारण मामला" उदाहरण है। यह प्रत्येक बैच की त्रुटि को चलाएगा, जिसका अर्थ है कि यदि आपका बैच दोगुना हो गया है, तो आपकी लागत का दोगुना मूल्य (और ढाल का परिमाण) होगा। कम से कम_मैं करने के लिए सरल परिवर्तन करना बहुत कम से कम डिबगिंग करना और सेटिंग्स के साथ खेलना मेरी राय में अधिक समझ में आता है।

— न्यूरॉन

Answer 1

यह उत्तर लागत कार्यों के सामान्य पक्ष पर है, जो TensorFlow से संबंधित नहीं है, और ज्यादातर आपके प्रश्न के "इस विषय के बारे में कुछ स्पष्टीकरण" को संबोधित करेंगे।

ज्यादातर उदाहरणों / ट्यूटोरियल में मैंने अनुसरण किया, उपयोग किया गया लागत समारोह कुछ हद तक मनमाना था। बिंदु एक विशिष्ट विधि से पाठक को परिचित कराने के लिए अधिक था, विशेष रूप से लागत फ़ंक्शन के लिए नहीं। यह आपको टूल से परिचित होने के लिए ट्यूटोरियल का पालन करने के लिए नहीं रोकना चाहिए, लेकिन मेरा जवाब आपको अपनी समस्याओं के लिए लागत फ़ंक्शन का चयन करने में मदद करना चाहिए।

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

---

वांछित परिणाम प्राप्त करने के लिए सही लागत फ़ंक्शन का चयन करना मशीन सीखने की समस्याओं का एक महत्वपूर्ण बिंदु है। मूल दृष्टिकोण, यदि आप ठीक से नहीं जानते हैं कि आप अपने तरीके से क्या चाहते हैं, तो प्रतिगमन समस्याओं के लिए मीन स्क्वायर त्रुटि (विकिपीडिया) का उपयोग करना है और वर्गीकरण समस्याओं के लिए त्रुटि का प्रतिशत। हालांकि, यदि आप अपनी विधि से अच्छे परिणाम चाहते हैं, तो आपको अच्छे को परिभाषित करने की आवश्यकता है , और इस प्रकार पर्याप्त लागत फ़ंक्शन को परिभाषित करना चाहिए। यह दोनों डोमेन ज्ञान (आपका डेटा क्या है, आप क्या हासिल करने की कोशिश कर रहे हैं), और आपके निपटान में उपकरणों का ज्ञान है।

मुझे विश्वास नहीं है कि मैं आपको TensorFlow में पहले से लागू लागत कार्यों के माध्यम से मार्गदर्शन कर सकता हूं, क्योंकि मुझे उपकरण का बहुत कम ज्ञान है, लेकिन मैं आपको विभिन्न लागत कार्यों को लिखने और उनका आकलन करने के बारे में एक उदाहरण दे सकता हूं।

---

लागत कार्यों के बीच विभिन्न अंतरों को समझने के लिए, आइए हम बाइनरी वर्गीकरण समस्या के उदाहरण का उपयोग करें, जहां हम चाहते हैं, प्रत्येक नमूने के लिए , वर्ग ।$x_n$$f(x_n) \in \{0,1\}$

कम्प्यूटेशनल गुणों के साथ शुरू करना ; "एक ही चीज़" को मापने वाले दो कार्य कैसे भिन्न परिणाम दे सकते हैं। निम्नलिखित, सरल लागत फ़ंक्शन लें; त्रुटि का प्रतिशत। यदि आपके पास नमूने हैं, तो पूर्वानुमानित वर्ग है और सही वर्ग है, तो आप कम से कम करना चाहते हैं$N$$f(y_n)$$y_n$

• $\frac{1}{N} \sum_n \left\{ \begin{array}{ll} 1 & \text{ if } f(x_n) \not= y_n\\ 0 & \text{ otherwise}\\ \end{array} \right. = \sum_n y_n[1-f(x_n)] + [1-y_n]f(x_n)$ ।

इस लागत समारोह में आसानी से व्याख्या करने योग्य होने का लाभ है। हालांकि, यह चिकना नहीं है; यदि आपके पास केवल दो नमूने हैं, तो फ़ंक्शन "कूदता है" 0 से 0.5 तक, 1. यह असंगतता को जन्म देगा यदि आप इस फ़ंक्शन पर ग्रेडिएंट वंश का उपयोग करने का प्रयास करते हैं। इससे बचने का एक तरीका असाइनमेंट की संभावनाओं का उपयोग करने के लिए लागत फ़ंक्शन को बदलना है; । फ़ंक्शन बन जाता है$p(y_n = 1 | x_n)$

• $\frac{1}{N} \sum_n y_n p(y_n = 0 | x_n) + (1 - y_n) p(y_n = 1 | x_n)$ |

यह फ़ंक्शन स्मूथ है, और एक ढाल वंश दृष्टिकोण के साथ बेहतर काम करेगा। आपको एक 'महीन' मॉडल मिलेगा। हालाँकि, इसकी अन्य समस्या है; यदि आपके पास एक नमूना है जो अस्पष्ट है, तो कि आपके पास से बेहतर कुछ भी कहने के लिए पर्याप्त जानकारी नहीं है । फिर, इस लागत फ़ंक्शन पर ग्रेडिएंट डिसेंट का उपयोग करके एक मॉडल का नेतृत्व किया जाएगा जो इस संभावना को यथासंभव बढ़ाता है, और इस प्रकार, शायद, ओवरफिट।$p(y_n = 1 | x_n) = 0.5$

इस फ़ंक्शन की एक और समस्या यह है कि यदि जबकि , तो आप सही होना निश्चित हैं, लेकिन आप गलत हैं। इस समस्या से बचने के लिए, आप संभाव्यता का लॉग ले सकते हैं, । जैसा कि और , निम्न फ़ंक्शन में पिछले संस्करण में वर्णित समस्या नहीं है:$p(y_n = 1 | x_n) = 1$$y_n = 0$$\log p(y_n | x_n)$$\log(0) = \infty$$\log(1) = 0$

• $\frac{1}{N} \sum_n y_n \log p(y_n = 0 | x_n) + (1 - y_n) \log p(y_n = 1 | x_n)$ ।

यह स्पष्ट करना चाहिए कि एक ही चीज़ का अनुकूलन करने के लिए , त्रुटि का प्रतिशत, अलग-अलग परिभाषाएं अलग-अलग परिणाम दे सकती हैं यदि वे समझदारी से बनाना आसान हैं, तो कम्प्यूटेशनल रूप से।

ही अवधारणा को मापने के लिए लागत और लिए संभव है , लेकिन आपके तरीके को तुलना में बेहतर परिणाम दे सकता है ।$A$$B$$A$$B$

---

अब देखते हैं कि विभिन्न लागत फ़ंक्शन विभिन्न अवधारणाओं को कैसे माप सकते हैं। सूचना पुनर्प्राप्ति के संदर्भ में, जैसा कि Google खोज में है (यदि हम रैंकिंग को अनदेखा करते हैं), हम चाहते हैं कि परिणाम लौटाए जाएं

• उच्च परिशुद्धता है , अप्रासंगिक जानकारी नहीं लौटाएं
• उच्च याद रखें , जितना संभव हो उतना प्रासंगिक परिणाम लौटाएं
• परिशुद्धता और याद (विकिपीडिया)

ध्यान दें कि यदि आपका एल्गोरिथ्म सब कुछ लौटाता है , तो यह संभव हर प्रासंगिक परिणाम लौटाएगा, और इस तरह से उच्च रिकॉल होगा, लेकिन बहुत खराब परिशुद्धता है। दूसरी ओर, यदि यह केवल एक तत्व लौटाता है, तो वह जो सबसे निश्चित है वह प्रासंगिक है, इसमें उच्च परिशुद्धता लेकिन कम याद होगा।

इस तरह के एल्गोरिदम का न्याय करने के लिए, सामान्य लागत फ़ंक्शन -score (विकिपीडिया) है । सामान्य मामला -score है, जो सटीक और याद करने के लिए समान वजन देता है, लेकिन सामान्य मामला यह -score है, और आप पाने के लिए को ट्वीक कर सकते हैं$F$$F_1$$F_\beta$$\beta$

• यदि आप उपयोग करते हैं, तो उच्च रीकॉल करें$\beta > 1$
• उच्च परिशुद्धता, यदि आप उपयोग करते हैं ।$\beta < 1$

ऐसे परिदृश्य में, लागत फ़ंक्शन चुनना यह चुनना है कि आपके एल्गोरिदम को व्यापार-बंद क्या करना चाहिए ।

एक और उदाहरण जो अक्सर सामने आता है वह है चिकित्सा निदान का मामला, आप एक लागत फ़ंक्शन का चयन कर सकते हैं जो अधिक झूठे नकारात्मक या गलत सकारात्मक को दंडित करता है जो कि बेहतर हो सकता है:

• अधिक स्वस्थ लोगों को बीमार के रूप में वर्गीकृत किया जा रहा है (लेकिन तब, हम स्वस्थ लोगों का इलाज कर सकते हैं, जो महंगा है और उन्हें चोट लग सकती है अगर वे वास्तव में बीमार नहीं हैं)
• अधिक बीमार लोगों को स्वस्थ के रूप में वर्गीकृत किया जा रहा है (लेकिन तब, वे बिना इलाज के मर सकते हैं)

---

अंत में, लागत फ़ंक्शन को परिभाषित करना आपके एल्गोरिथ्म के लक्ष्य को परिभाषित कर रहा है। एल्गोरिथ्म परिभाषित करता है कि वहां कैसे पहुंचा जाए।

---

साइड नोट: कुछ लागत कार्यों में अपने लक्ष्यों को प्राप्त करने के लिए अच्छा एल्गोरिथ्म है। उदाहरण के लिए, एसवीएम (विकिपीडिया) में दोहरी समस्या को हल करके, न्यूनतम हानि (विकिपीडिया) का एक अच्छा तरीका मौजूद है

Answer 2

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

$-\frac{1}{n} \sum(y\_train * \log(y\_output) + (1 - y\_train) \cdot \log(1 - y\_output))$

आपने जो उल्लेख किया है वह केवल बाइनरी क्रॉस एन्ट्रॉपी लॉस है जहां आप मानते हैं कि स्केलर है और फिर से एक स्केलर है जो आउटपुट 1 होने की संभावना को दर्शाता है।$y\_train$$y\_output$

आपके द्वारा उल्लिखित अन्य समीकरण, कई वर्गों तक फैले उस का एक अधिक सामान्य संस्करण है

-tf.reduce_sum(y_train * tf.log(y_output)) लेखन के रूप में एक ही बात है

$-\sum_n train\_prob \cdot \log (out\_prob)$

जहाँ कई वर्गों के ऊपर योग है और प्रत्येक वर्ग के लिए संभाव्यताएँ हैं। स्पष्ट रूप से द्विआधारी मामले में यह ठीक वैसी ही बात है जैसा कि पहले उल्लेख किया गया था। के रूप में यह नुकसान न्यूनीकरण के लिए किसी भी तरह से योगदान नहीं करता, क्योंकि यह एक स्थिर है अवधि छोड़ा गया है।$n$

Answer 3

BLUF: डेटा और मैटलोट्लिब के सबसेट के साथ पुनरावृत्ति परीक्षण और त्रुटि।

लंबा जवाब:

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

आप एक लागत फ़ंक्शन के लिए लक्ष्य करना चाहते हैं जो एल्गोरिथ्म और डेटा सेट की आपकी विशिष्ट पसंद के लिए चिकनी और उत्तल है। ऐसा इसलिए है क्योंकि आप चाहते हैं कि आपका एल्गोरिथ्म आत्मविश्वास से और कुशलता से वजन को समायोजित करने में सक्षम हो और अंततः उस लागत फ़ंक्शन के वैश्विक न्यूनतम तक पहुंच सके। यदि आपकी लागत फ़ंक्शन स्थानीय अधिकतम और न्यूनतम के साथ "ऊबड़" है, और / या कोई वैश्विक न्यूनतम नहीं है, तो आपके एल्गोरिथ्म में एक कठिन समय हो सकता है; इसके भार केवल सभी जगह पर कूद सकते हैं, अंततः आपको सटीक और / या सुसंगत पूर्वानुमान देने में विफल रहे।

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

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

आप MSE और अपने डेटा के एक छोटे और सरल नमूने का उपयोग करके या इस प्रयोग के लिए आपके द्वारा बनाए गए नकली डेटा के साथ एक परीक्षण चलाकर शुरू कर सकते हैं। Matplotlib (या जो भी प्लॉटिंग समाधान आप पसंद करते हैं) के साथ चल रहा है। क्या परिणामस्वरूप त्रुटि वक्र चिकनी और उत्तल है? एक अतिरिक्त इनपुट चर के साथ फिर से प्रयास करें ... क्या परिणामस्वरूप सतह अभी भी चिकनी और उत्तल है? इस प्रयोग के माध्यम से आप पा सकते हैं कि MSE आपकी समस्या / समाधान के लायक नहीं है, लेकिन क्रॉस एन्ट्रापी आपको एक चिकनी उत्तल आकृति प्रदान करता है जो आपकी आवश्यकताओं को बेहतर ढंग से फिट करता है। तो आप कोशिश कर सकते हैं कि एक बड़ा नमूना डेटा सेट देखें और देखें कि क्या परिकल्पना अभी भी है। और अगर ऐसा होता है, तो आप इसे अपने पूरे प्रशिक्षण सेट के साथ कुछ बार आज़मा सकते हैं और देख सकते हैं कि यह कैसा प्रदर्शन करता है और यदि यह लगातार समान मॉडल प्रदान करता है। यदि ऐसा नहीं होता है, तो एक और लागत फ़ंक्शन चुनें और प्रक्रिया को दोहराएं।

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

बेशक, इस परीक्षण और त्रुटि का एक बहुत पहले से ही अन्य लोगों द्वारा किया गया है, इसलिए हम इस प्रक्रिया में जल्दी लागत के अच्छे कार्य हो सकते हैं के हमारे विकल्पों को फ़िल्टर करने में हमारी मदद करने के लिए सार्वजनिक ज्ञान का लाभ उठाते हैं। उदाहरण के लिए, क्रॉस एन्ट्रॉपी आमतौर पर वर्गीकरण की समस्याओं के लिए एक अच्छा विकल्प है, चाहे वह उपर्युक्त उदाहरण जैसे लॉजिस्टिक रिग्रेशन के साथ बाइनरी वर्गीकरण हो या आउटपुट के रूप में सॉफ्टमैक्स परत के साथ अधिक जटिल मल्टी-लेबल वर्गीकरण। जबकि MSE रैखिक प्रतिगमन समस्याओं के लिए एक अच्छी पहली पसंद है, जहाँ आप संभावित श्रेणियों के ज्ञात सेट से बाहर किसी ज्ञात श्रेणी में सदस्यता की संभावना के बजाय एक स्केलर भविष्यवाणी की मांग कर रहे हैं, जिसमें आपके उत्पादन के रूप में सॉफ्टमैक्स परत के बजाय ' d केवल एक सक्रियण फ़ंक्शन के बिना इनपुट प्लस पूर्वाग्रह का भारित योग हो सकता है।

उम्मीद है कि यह उत्तर अन्य शुरुआती लोगों को अत्यधिक सरल और स्पष्ट होने के बिना वहां से बाहर निकलने में मदद करता है।

Answer 4

अपने सवाल को फिर से

सबसे TensorFlow उदाहरणों में (1 - y_train) * लॉग (1 - y_output) भाग कहां है? क्या यह याद नहीं है?

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

उदाहरण के लिए:

अनुकूलन से पहले

y_output = [0.2, 0.2, 0.6] तथा y_train = [0, 0, 1]

अनुकूलन के बाद

y_output = [0.15, 0.15, 0.7] तथा y_train = [0, 0, 1]

यहाँ देखें कि भले ही हमने तीसरा कार्यकाल बढ़ाया, बाकी सभी शब्द स्वतः कम हो गए