👩🏽‍💻 👩‍❤️‍💋‍👩 😴 रैखिक द्विआधारी वर्गीकरण समस्या में आयाम में कमी (जैसे SVM) 👐🏾 🧖🏼 ✌🏾

आवश्यक ज्ञान: रैखिक द्विआधारी वर्गीकरण विधियों (जैसे SVM ट्यूटोरियल देखें), रैखिक बीजगणित, रैखिक प्रोग्रामिंग के साथ परिचित

रैखिक बाइनरी वर्गीकरण समस्या पर विचार करें (यदि समस्या रैखिक रूप से अविभाज्य है, तो इसे सिमेट्रिक इंटीग्रल एल -2 कर्नेल ( एसवीएम देखें) का उपयोग करके इसे कम किया जा सकता है।

इस तरह की समस्या को हल करते समय, वर्गीकृत तत्वों (बाद में नमूनों के रूप में संदर्भित) को आयाम n के वेक्टर स्थान के तत्वों के रूप में दर्शाया जाता है। व्यवहार में, ऐसी समस्याओं में, n बहुत बड़ी हो सकती है, उदाहरण के लिए, जीन को वर्गीकृत करने के कार्य के लिए, यह हजारों में हो सकता है। एक बड़े आयाम में प्रवेश होता है, एक उच्च संगणना समय के अलावा, संख्यात्मक गणनाओं की एक संभावित उच्च त्रुटि। इसके अलावा, बड़े आयाम के उपयोग के लिए बड़ी वित्तीय लागत (प्रयोगों के लिए) की आवश्यकता हो सकती है। सवाल यह है: क्या यह संभव है और नमूनों के तुच्छ घटकों को त्यागकर n को कैसे कम किया जाए ताकि नमूनों को अलग से "कोई बदतर" नई जगह (रैखिक रूप से अलग होने में) या "बहुत खराब नहीं" हो।

अपने लेख में, मैं इस लेख Gene_Selection_for_Cancer_Classification_use से विधि का एक संक्षिप्त अवलोकन के साथ शुरू करना चाहता हूं , और फिर अपनी खुद की विधि प्रस्तावित करता हूं।

Gene_Selection_for_Cancer_Classification_use से एल्गोरिदम

Gene_Selection_for_Cancer_Classification_using में आयामी कमी विधि का मुख्य विचार सभी घटकों को रैंक करना है। निम्नलिखित एल्गोरिदम प्रस्तावित है:

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

मूल रूप से, लेख प्राप्त एसवीएम के भार को असाइन करने की विधि पर विचार करता है। अर्थात, हम इसी घटकों के वर्गीकरण फ़ंक्शन में गुणांक का उपयोग वज़न के रूप में करते हैं। मान लीजिए एसवीएम के प्रशिक्षण के बाद हमें एक वर्गीकृत कार्य (डब्ल्यू, एक्स) + बी = 0 मिला, तो वाईआई घटक का भार घटक i होगा। लेख में वजन सेट करने के सहसंबंध विधि पर भी चर्चा की गई है, लेकिन यह किसी भी अन्य की तरह, SVM विधि से हार जाता है, क्योंकि जब यह चरण 1 में बदल जाता है, तो SVM विधि में वजन चरण 3 से जाना जाता है।

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

पुनश्च इसके अलावा, वाई की तरह वजन का विकल्प काफी विवादास्पद है। मैं सभी नमूनों के लिए घटक i के नमूने प्रसरण द्वारा कम से कम उन्हें गुणा करने या सभी नमूनों के लिए घटक i के पहले केंद्रीय पूर्ण नमूनाकरण क्षण का सुझाव दूंगा।

मेरा एल्गोरिथ्म

विचार यह है: हम घटक को छोड़ देते हैं और जांचते हैं कि क्या अब (इस घटक के बिना) नमूनों का सेट रैखिक रूप से अलग होगा। यदि हाँ, तो इस घटक को वापस न करें, यदि नहीं, तो वापस करें। सवाल यह है कि रैखिक पृथक्करण के लिए सेट की जांच कैसे की जाए?
Xi नमूने होने दें, yi नमूना वर्ग का है (yi = -1 प्रथम श्रेणी है, yi = 1 द्वितीय श्रेणी है) i = 1..m। तब नमूने रैखिक रूप से वियोज्य होते हैं यदि

$A \ Alpha \ ge0$

- एक गैर तुच्छ समाधान है, जहां

$A = \ big \ left (\ start {array} {c.cccc} & 1 & 2 & \ cdots & n & n + 1 \\\ hdash1 & y_1x_ {11} & y_1x_ {12} & cdots & y_1x_ {1n} & y_1 \\ 2 & y_2x) और {21-21} & \ cdots & y_2x_ {2n} & y_2 \\ ♥ vdots & \ vdots & \ vdots & \ ddots & \ vdots \\ m & y_mx_ {m1} और y_mx_ {m2} & \ cdots & y_mx_ {mn} & yd end_md$

(एसवीएम प्रशिक्षण में स्थितियां)।
_____________________________________________________________________________________
सबसे पहले, आइए देखें कि आप सख्त रैखिक पृथक्करण के लिए सेट की जाँच कैसे कर सकते हैं:

$ए \ अल्फा> 0$

- एक समाधान है। फ़र्कश के लेम्मा द्वारा <=>

$\ बाएँ \ {\ {शुरू {eqnarray} A ^ T \ beta = 0 \\\ बीटा \ ge0 \ end {eqnarray}$

- केवल एक तुच्छ समाधान है। हम प्राप्त बाधाओं और उद्देश्य फ़ंक्शन के साथ रैखिक प्रोग्रामिंग समस्या में इष्टतमता के लिए वेक्टर 0 की जांच करते हैं

$\ mathbf {1} ^ T \ Beta \ to अधिकतम$

यदि 0 इष्टतम हुआ, तो सेट सख्ती से रैखिक रूप से अलग है।
_____________________________________________________________________________________
लक्स रैखिक विभाज्यता:

$A \ Alpha \ ge0$

- एक गैर तुच्छ समाधान है। फ़र्कश के लेम्मा द्वारा <=>

$\ बाएँ \ {\ {शुरू {eqnarray} A ^ T \ Beta = 0 \\\ beta> 0 \\\ end {eqnarray}$

- कोई निर्णय नहीं है। <=>

$\ left \ {\ {शुरू {eqnarray} A ^ T \ beta = 0 \\ बीटा बीटा \ ge1 \\\ अंत {eqnarray}$

- कोई निर्णय नहीं है। प्राप्त बाधाओं के समाधान के लिए जाँच करने के लिए, इन बाधाओं के साथ एक रैखिक प्रोग्रामिंग समस्या में प्रारंभिक समर्थन वेक्टर को खोजने के लिए किसी भी विधि का उपयोग किया जा सकता है।
_____________________________________________________________________________________
कुछ समस्याओं में (विशेषकर जब आयाम (n) नमूनों की संख्या (m) से अधिक है) हम घटक को त्यागना चाहते हैं यदि सेट का पृथक्करण एक निश्चित अंतराल के साथ होता है। तो आप निम्न स्थितियों की जांच कर सकते हैं:

$\ बायाँ \ _ \ _ शुरू {eqnarray} एक \ Alpha \ ge c \\ - 1 \ le \ Alpha \ le 1 \\\ अंत {eqnarray}$

- एक समाधान है जहां c > = 0 गैप पैरामीटर है, और दूसरा प्रतिबंध सामान्यीकरण अल्फा को बदल देता है (ताकि ए * x > 0 को केवल एक पर्याप्त बड़े निरंतर k द्वारा गुणा करके और सिस्टम A * * x > = c ) को संतुष्ट करना असंभव है। फ़र्कश के लेम्मा (ई पहचान मैट्रिक्स है) द्वारा इन शर्तों <=>

$\ left \ {\ {शुरू {eqnarray} (A ^ TE -E) \ Beta = 0 \\\ beta \ ge 0 \\ (c ^ T -1 ^ T -1 ^ T) \ बीटा> 0 \ end {eqnarray }$

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

(c ^ T -1 ^ T -1 ^ T) अधिकतम करने के लिए बीटा

यदि 0 इष्टतम हो गया है, तो सेट को एक दिए गए अंतर के साथ विभाजित किया जा सकता है।
_____________________________________________________________________________________
कुछ समस्याओं में (विशेषकर जब नमूनों की संख्या आयाम (n) से अधिक होती है), हम घटक को त्यागना चाहते हैं, भले ही सेट का पृथक्करण कुछ त्रुटि के साथ हो। तो आप निम्न स्थितियों की जांच कर सकते हैं:

$\ left \ {\ _ शुरू करें {eqnarray} एक \ Alpha \ ge c \\\ left \ [\ start \ eqnarray} \ Alpha \ ge 1 \\\ Alpha \ le -1 \\\ end {eqnarray} \ end \ eqnarray }$

- एक समाधान है, जहां c <= 0 त्रुटि पैरामीटर है, और दूसरा अवरोध सामान्यीकरण अल्फा को प्रतिस्थापित करता है (ताकि समाधान A * x > negative_number_less_than_ c को पर्याप्त रूप से बड़े निरंतर k द्वारा विभाजित नहीं किया जा सके और सिस्टम A * x / k> = c ) को संतुष्ट करें। यहां, सब कुछ ऊपर वर्णित मामले के समान है, केवल इसलिए कि अव्यवस्था (वर्ग ब्रैकेट) के कारण आपको दो रैखिक प्रोग्रामिंग समस्याओं पर विचार करना होगा।

रैखिक द्विआधारी वर्गीकरण समस्या में आयाम में कमी (जैसे SVM)

Gene_Selection_for_Cancer_Classification_use से एल्गोरिदम

मेरा एल्गोरिथ्म

More articles: