लॉजिस्टिक रिग्रेशन में लागत समारोह का पायथन कार्यान्वयन: क्यों एक अभिव्यक्ति में डॉट गुणा लेकिन दूसरे में तत्व-वार गुणा

19

मेरा एक बहुत ही बुनियादी सवाल है जो लॉजिस्टिक रिग्रेशन की सेटिंग में पायथन, मैटिपीस और मैट्रिसेस के गुणा से संबंधित है।

सबसे पहले, मैं गणित अंकन का उपयोग नहीं करने के लिए माफी माँगता हूँ।

मैं मैट्रिक्स डॉट गुणा बनाम तत्व वार पुल्टिप्लीकेशन के उपयोग के बारे में उलझन में हूं। लागत समारोह द्वारा दिया गया है:

और अजगर में मैंने ऐसा लिखा है

    cost = -1/m * np.sum(Y * np.log(A) + (1-Y) * (np.log(1-A)))

लेकिन उदाहरण के लिए इस अभिव्यक्ति (पहले एक - डब्ल्यू के संबंध में जे के व्युत्पन्न)

है

   dw = 1/m * np.dot(X, dz.T)

मुझे समझ में नहीं आया कि उपरोक्त में डॉट गुणा का उपयोग करना सही क्यों है, लेकिन लागत फ़ंक्शन में तत्व वार गुणा का उपयोग करें अर्थात क्यों:

   cost = -1/m * np.sum(np.dot(Y,np.log(A)) + np.dot(1-Y, np.log(1-A)))

मुझे पूरी तरह से पता है कि यह विस्तृत रूप से नहीं बताया गया है, लेकिन मैं यह अनुमान लगा रहा हूं कि यह प्रश्न इतना सरल है कि किसी को भी मूल लॉजिस्टिक प्रतिगमन अनुभव से मेरी समस्या समझ में आ जाएगी।

python logistic-regression cost-function

— भूत चालक
स्रोत

2

क्या आप गणित के फार्मूले या गणित के फॉर्मूले और कोड के बीच अनुवाद पर सवाल उठा रहे हैं? यानी क्या आप जानना चाहते हैं कि लागत फ़ंक्शन को राशि के रूप में क्यों व्यक्त किया गया है और ढाल की गणना मैट्रिक्स गुणन के रूप में व्यक्त की गई है; या आप को समझना चाहते हैं क्यों हो जाता है , जबकि हो जाता है ?

y_{i} log (a_{i})

$y_i\text{log}(a_i)$ Y * np.log(A)

X (A - Y)^{T}

$X(A-Y)^T$ np.dot(X, dz.T)

— नील स्लेटर

2

धन्यवाद नील। अस्पष्टता के लिए क्षमा करें। द्वितीय। मैं गणित के फॉर्मूले को समझता हूं। मैं सिर्फ एक में डॉट गुणा के लिए अंतर्ज्ञान के आसपास अपना सिर नहीं पा सकता हूं, और दूसरे में तत्व वार गुणा

— घोस्टइडर

12

इस स्थिति में, दो गणित सूत्र आपको गुणा का सही प्रकार दिखाते हैं:

$y_i$ लागत समारोह में और अदिश मान हैं। अदिश मानों को प्रत्येक उदाहरण पर दिए गए योग में बदलने से यह परिवर्तित नहीं होता है, और आप इस राशि में एक उदाहरण के मूल्यों को दूसरे के साथ कभी नहीं जोड़ते हैं। तो के प्रत्येक तत्व केवल में इसके मिलान तत्व साथ सूचना का आदान , जो मूल रूप से तत्व के लिहाज से की परिभाषा है। $\text{log}(a_i)$ $y$ $a$
ग्रेडिएंट गणना में शब्द मैट्रिसेस हैं, और यदि आप जैसे नोटेशन का उपयोग करते हुए दो मैट्रिसेस और गुणा करते हैं , तो आप इसे और अधिक जटिल योग के रूप में लिख सकते हैं: । कई प्रदर्शनों के बीच यह आंतरिक योग है। $A$ $B$ $C = AB$ $C_{ik} = \sum_j A_{ij}B_{jk}$ np.dot

आपके भ्रम के कारण पाठ्यक्रम सामग्री में समीकरणों पर लागू किए गए सदिशीकरण से उपजी है , जो अधिक जटिल परिदृश्यों की प्रतीक्षा कर रहे हैं। आप वास्तव में उपयोग cost = -1/m * np.sum( np.multiply(np.log(A), Y) + np.multiply(np.log(1-A), (1-Y)))या cost = -1/m * np.sum( np.dot(np.log(A), Y.T) + np.dot(np.log(1-A), (1-Y.T)))whilst कर सकते हैं Yऔर Aआकार है (m,1)और यह एक ही परिणाम देना चाहिए। NB np.sumकेवल उस में एक ही मूल्य को समतल कर रहा है, इसलिए आप इसे छोड़ सकते हैं और इसके बजाय [0,0]अंत में रख सकते हैं। हालांकि, यह अन्य आउटपुट आकृतियों के लिए सामान्यीकृत नहीं है, (m,n_outputs)इसलिए पाठ्यक्रम इसका उपयोग नहीं करता है।

— नील स्लेटर
स्रोत

1

नील - हाँ, तुम सही हो। एंड्रयू एनजीएस नया डीएल पाठ्यक्रम। और आपका जवाब भी सही समझ में आता है। इनपुट के लिए धन्यवाद।

— घोस्टइडर

"तो y का प्रत्येक तत्व केवल अपने मिलान तत्व के साथ अंतःक्रिया करता है, जो मूल रूप से तत्व-वार की परिभाषा है" - अविश्वसनीय रूप से स्पष्ट व्याख्या।

— घोस्टइडर

2

क्या आप पूछ रहे हैं, दो वैक्टरों के एक डॉट उत्पाद के बीच अंतर क्या है, और उनके मूल उत्पाद को समेटें? वह एक जैसे है। np.sum(X * Y)है np.dot(X, Y)। डॉट संस्करण आम तौर पर अधिक कुशल और समझने में आसान होगा।

$Y$ np.dot

इसलिए मुझे लगता है कि इसका उत्तर यह है कि वे अलग-अलग काम कर रहे हैं, और ये स्थितियाँ अलग हैं, और मुख्य अंतर वैक्टर बनाम परिपक्वता के साथ काम कर रहा है।

— सीन ओवेन
स्रोत

धन्यवाद। यह काफी नहीं है कि मैं क्या पूछ रहा हूँ। मेरे पास लागत फ़ंक्शन (कोड का अंतिम बिट) के लिए वैकल्पिक कोड देखें। यह गलत है, लेकिन मैं यह समझने की कोशिश कर रहा हूं कि यह गलत क्यों है।

— घोस्टइडर

2

ओपी के मामले np.sum(a * y)में वैसा ही नहीं होने जा रहा है np.dot(a, y)क्योंकि aऔर yकॉलम वैक्टर आकार के होते हैं (m,1), इसलिए dotफ़ंक्शन एक त्रुटि बढ़ाएगा। मुझे पूरा यकीन है कि यह सब coursera.org/learn/neural-networks-deep-learning (एक कोर्स जिसे मैंने अभी हाल ही में देखा है) से किया गया है, क्योंकि नोटेशन और कोड एक सटीक मेल है।

— नील स्लेटर

0

के संबंध में "ओपी के मामले में np.sum (a * y) np.dot (a, y) के समान नहीं होने वाला है क्योंकि a और y स्तंभ वैक्टर आकार (m, 1) हैं, इसलिए डॉट फ़ंक्शन होगा एक त्रुटि बढ़ाएँ। "...

(मेरे पास टिप्पणी बटन का उपयोग करके टिप्पणी करने के लिए पर्याप्त कुडोस नहीं हैं लेकिन मुझे लगा कि मैं जोड़ूंगा ..)

यदि वैक्टर कॉलम वैक्टर हैं और उनका आकार (1, m) है, तो एक सामान्य पैटर्न यह है कि डॉट फ़ंक्शन के लिए दूसरा ऑपरेटर ".T" ऑपरेटर के साथ इसे आकार (m, 1) और फिर डॉट को स्थानांतरित करने के लिए पोस्टफ़िक्स किया गया है। उत्पाद एक (1, m) (m, 1) के रूप में कार्य करता है। जैसे

np.dot (np.log (1-A), (1-Y) .T)

एम के लिए सामान्य मूल्य डॉट उत्पाद (मैट्रिक्स गुणन) को लागू करने में सक्षम बनाता है।

इसी तरह कॉलम वैक्टर के लिए पहले नंबर जैसे np.dot (wT, X) में लगाए गए ट्रांसपोज़ को 'बीच' में> 1> का आयाम देना होगा।

Np.dot से स्केलर प्राप्त करने के लिए पैटर्न दो वैक्टर आकृतियों को 'बाहर' पर '1' आयाम और 'अंदर' पर आम> 1 आयाम पाने के लिए है:

(1, X)। (X, 1) या np.dot (V1, V2) जहां V1 आकार है (1, X) और V2 आकार है (X, 1)

इसलिए परिणाम एक (1,1) मैट्रिक्स, यानी एक स्केलर है।

— गॉर्डन हचिसन
स्रोत