मशीन लर्निंग में रेग्युलराइज़ेशन: L1, L2, और इलैस्टिक नेट समझाया गया

तो, आपने एक ऐसा मॉडल ट्रेन किया है जो लगभग हर प्रशिक्षण उदाहरण पर बेहतरीन चलता है, लेकिन नए डेटा पर फेल हो जाता है? हम सब इस स्थिति में रहे हैं।

यही ओवरफिटिंग की उच्च-स्तरीय परिभाषा है। आपके मॉडल ने असली पैटर्न नहीं सीखा, बल्कि प्रशिक्षण डेटा को रट लिया। प्रोडक्शन वातावरण में, जहाँ नया और अनदेखा डेटा आता है, मॉडल ऐसी भविष्यवाणियाँ करेगा जिन पर आप भरोसा नहीं करेंगे। वास्तविक दुनिया का डेटा जितना प्रशिक्षण नमूनों से अलग होगा, समस्या उतनी बढ़ेगी।

रेग्युलराइज़ेशन इसे लॉस फ़ंक्शन में एक पेनल्टी जोड़कर ठीक करता है। यह पेनल्टी जटिल मॉडलों को हतोत्साहित करती है। यानी, यह वह तंत्र है जो आपके मॉडल को हर डेटा पॉइंट पर फिट होने से रोकता है और उसे सामान्यीकरण करने के लिए बाध्य करता है।

इस लेख में, मैं रेग्युलराइज़ेशन के पीछे की सहज समझ, सबसे आम तरीके - L1, L2, और इलैस्टिक नेट - और अपने उपयोग-केस के लिए सही विकल्प चुनने का तरीका समझाऊँगा।

यदि आप समझना चाहते हैं कि प्रोडक्शन में मशीन लर्निंग मॉडल क्यों और कैसे फेल होते हैं, तो हमारा बायस-वैरिएंस ट्रेडऑफ ब्लॉग पोस्ट पढ़ें।

मशीन लर्निंग में रेग्युलराइज़ेशन क्या है

रेग्युलराइज़ेशन एक तकनीक है जो आपके मॉडल के लॉस फ़ंक्शन में एक पेनल्टी टर्म जोड़ती है ताकि जटिलता को हतोत्साहित किया जा सके।

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

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

यही संतुलन मॉडल की लचीलेपन को नियंत्रित करता है।

एक अत्यधिक लचीला मॉडल प्रशिक्षण डेटा को फिट करने के लिए किसी भी आकार में खुद को मोड़ सकता है। रेग्युलराइज़ेशन उसे फिर से एक सरल आकार में समतल करता है - ऐसा जो उन डेटा पर भी टिक सके जिन्हें मॉडल ने पहले नहीं देखा।

रेग्युलराइज़ेशन की आवश्यकता क्यों है

हर मॉडल जिसे आप ट्रेन करते हैं, दो अनुपयोगी मॉडलों के बीच कहीं न कहीं स्थित होता है: एक जो बहुत सरल है और एक जो बहुत जटिल है।

बहुत सरल मॉडल आपके डेटा के असली पैटर्न को “समझ” नहीं पाता। वह सिग्नल को मिस कर देता है। इसे अंडरफिटिंग कहते हैं - मॉडल प्रशिक्षण डेटा और नए डेटा, दोनों पर ख़राब प्रदर्शन करता है।

बहुत जटिल मॉडल इसके विपरीत करता है। वह आपके प्रशिक्षण डेटा के हर विवरण को फिट कर देता है, शोर सहित। इसे ओवरफिटिंग कहते हैं - मॉडल प्रशिक्षण डेटा पर बेहतरीन चलता है, लेकिन नए डेटा पर फेल हो जाता है क्योंकि उसने गलत चीज़ें याद कर लीं।

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

नीचे दिया चार्ट बताता है कि व्यवहार में यह कैसा दिखता है।

बिलकुल-सही बनाम बहुत जटिल मॉडल

इसे ही बायस-वैरिएंस ट्रेडऑफ कहते हैं।

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

रेग्युलराइज़ेशन आपको दोनों का सर्वश्रेष्ठ पाने में मदद करता है। यह जटिलता को खत्म नहीं करता, लेकिन उसे दंडित करता है। नतीजतन, आपके मॉडल के पास असली सिग्नल सीखने का बेहतर मौका होता है।

रेग्युलराइज़ेशन कैसे काम करता है

हर मॉडल लॉस फ़ंक्शन को न्यूनतम करके सीखता है - यानी उसकी भविष्यवाणियाँ कितनी गलत हैं, इसका माप। बिना रेग्युलराइज़ेशन के, मॉडल का एकमात्र काम उस त्रुटि को घटाना होता है। वह इसके लिए कुछ भी करेगा, जिसमें प्रशिक्षण डेटा पर फिट होने वाले बड़े कोएफ़िशिएंट्स बनाना भी शामिल है, जो सामान्यीकृत नहीं होते।

रेग्युलराइज़ेशन उद्देश्य बदल देता है। केवल त्रुटि को घटाने के बजाय, अब मॉडल इसे न्यूनतम करता है:

रेग्युलराइज़ेशन कैसे काम करता है

पेनल्टी टर्म मॉडल के कोएफ़िशिएंट्स का एक फ़ंक्शन होता है। बड़े कोएफ़िशिएंट्स पेनल्टी बढ़ाते हैं। कुल लागत कम रखने के लिए, मॉडल को अपने कोएफ़िशिएंट्स छोटे रखने पड़ते हैं - जिसका मतलब है सरल, अधिक सामान्यीकृत समाधान।

λ (लैम्ब्डा) नियंत्रित करता है कि पेनल्टी कितनी मायने रखती है। ऊँचा λ मॉडल पर सरल रहने का अधिक दबाव डालता है। कम λ मॉडल को डेटा फिट करने पर ज़्यादा ध्यान देने देता है। नीचे “रेग्युलराइज़ेशन स्ट्रेंथ चुनना” खंड में आप इसे ट्यून करना देखेंगे।

मशीन लर्निंग में रेग्युलराइज़ेशन के प्रकार

मॉडल की जटिलता पर दंड लगाने के कुछ तरीके हैं। हर तरीका कोएफ़िशिएंट्स पर अलग तरह का दबाव डालता है, इसलिए वे अलग-अलग परिस्थितियों में उपयुक्त होते हैं।

L2 रेग्युलराइज़ेशन (रिज रिग्रेशन)

L2 रेग्युलराइज़ेशन हर कोएफ़िशिएंट के वर्ग मान को दंडित करता है। कोएफ़िशिएंट जितना बड़ा होगा, वह पेनल्टी में उतना ही अधिक योगदान देगा - और मॉडल उसे छोटा करने के लिए उतनी ही मेहनत करेगा।

L2 रेग्युलराइज़ेशन

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

L1 रेग्युलराइज़ेशन (लैसो रिग्रेशन)

L1 रेग्युलराइज़ेशन वर्ग के बजाय हर कोएफ़िशिएंट के परिमाण (absolute value) को दंडित करता है।

L1 रेग्युलराइज़ेशन

यह छोटा सा अंतर बड़ा नतीजा देता है। L1 कोएफ़िशिएंट्स को बिल्कुल शून्य तक धकेल सकता है, यानी वह फीचर्स को मॉडल से हटा देता है। आप इसे स्वत: फीचर चयन की तरह समझ सकते हैं। दूसरे शब्दों में, लैसो रेग्युलराइज़ेशन फीचर्स हटाकर आपके मॉडल को सरल बना सकता है।

L1 बनाम L2 रेग्युलराइज़ेशन

मूल अंतर विरलता (sparsity) पर आकर टिकता है। L1 विरल मॉडल बनाता है - केवल फीचर्स का एक उपसमुच्चय ही बचता है। L2 सघन (dense) मॉडल बनाता है - सभी फीचर्स बने रहते हैं, बस उनके वज़न छोटे हो जाते हैं।

यह व्याख्यनीयता को भी प्रभावित करता है। 5 सक्रिय फीचर्स वाला लैसो मॉडल समझाना 50 छोटे-छोटे योगदान वाले फीचर्स वाले रिज मॉडल की तुलना में आसान होता है। लेकिन जब फीचर्स आपस में सहसंबद्ध होते हैं तो रिज अधिक स्थिर रहता है, क्योंकि यह वज़न को उनके बीच बाँट देता है, किसी एक को मनमाने ढंग से चुनने के बजाय।

यहाँ मतभेदों का एक त्वरित अवलोकन है:

L1 बनाम L2 रेग्युलराइज़ेशन

यदि आप देखना चाहते हैं कि ये Python में कैसे तुलना करते हैं, तो हमारा Python में लैसो और रिज रिग्रेशन ट्यूटोरियल आपकी मदद करेगा।

इलैस्टिक नेट रेग्युलराइज़ेशन

इलैस्टिक नेट L1 और L2 को एकल पेनल्टी टर्म में जोड़ता है।

इलैस्टिक नेट रेग्युलराइज़ेशन

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

विभिन्न मॉडलों में रेग्युलराइज़ेशन

रेग्युलराइज़ेशन कई मशीन लर्निंग मॉडलों में दिखता है, लेकिन अलग-अलग रूपों में। मैं आपको दिखाता हूँ ये क्या हैं।

रेखीय रिग्रेशन (Linear regression) वह जगह है जहाँ अधिकांश लोग पहले रेग्युलराइज़ेशन देखते हैं। जब आप रेखीय रिग्रेशन में L2 जोड़ते हैं तो आपको रिज रिग्रेशन मिलता है। इसी तरह, L1 जोड़ने पर लैसो रिग्रेशन मिलता है। गणित वही है जैसा ऊपर बताया गया - लीस्ट स्क्वेयर्स लॉस में पेनल्टी टर्म जोड़ना।

लॉजिस्टिक रिग्रेशन भी उसी तरह काम करता है। लॉस फ़ंक्शन बदल जाता है - यह वर्ग त्रुटि के बजाय क्रॉस-एंट्रॉपी होता है - पर पेनल्टी टर्म समान रहता है। ज़्यादातर मशीन लर्निंग लाइब्रेरी लॉजिस्टिक रिग्रेशन पर डिफ़ॉल्ट रूप से L2 लागू करती हैं, इसलिए आपको scikit-learn में C नामक पैरामीटर दिखेगा। यह λ का व्युत्क्रम है, इसलिए छोटा C मतलब अधिक मज़बूत रेग्युलराइज़ेशन।

न्यूरल नेटवर्क कुछ अलग तरीकों का उपयोग करते हैं:

• वेट डिके: नेटवर्क के वेट्स पर L2 रेग्युलराइज़ेशन - सिद्धांत एक जैसा है, बस बहुत बड़े पैमाने पर
• ड्रॉपआउट: प्रशिक्षण के दौरान, यह हर पास में कुछ न्यूरॉन्स के एक अंश को यादृच्छिक रूप से निष्क्रिय कर देता है, जिससे नेटवर्क किसी एकल पथ पर अत्यधिक निर्भर नहीं होता।

दोनों ओवरफिटिंग को कम करते हैं, लेकिन अलग-अलग तरीकों से।

ट्री-आधारित मॉडल लॉस पेनल्टी का उपयोग बिल्कुल नहीं करते। इसके बजाय, वे प्रूनिंग से जटिलता को नियंत्रित करते हैं - यह सीमित करना कि एक ट्री कितनी गहराई तक बढ़ सकता है, या ऐसी शाखाओं को हटाना जो भविष्यवाणियों में पर्याप्त सुधार नहीं लातीं। scikit-learn में max_depth और min_samples_split जैसे हाइपरपैरामीटर्स रेग्युलराइज़ेशन पैरामीटर्स ही हैं, भले उन्हें ऐसा कहा न जाता हो।

रेग्युलराइज़ेशन और बायस-वैरिएंस ट्रेडऑफ

रेग्युलराइज़ेशन समझौतों के बारे में है।

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

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

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

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

रेग्युलराइज़ेशन की स्ट्रेंथ चुनना

एक मशीन लर्निंग प्रैक्टिशनर के रूप में, रेग्युलराइज़ेशन का प्रकार चुनने के बाद आपको उसकी स्ट्रेंथ सेट करनी होती है।

यह स्ट्रेंथ एक हाइपरपैरामीटर से नियंत्रित होती है - गणितीय संकेतन में आमतौर पर lambda (λ) कहलाता है, या scikit-learn में alpha। यह पेनल्टी टर्म के आगे का गुणक है। आप इसे बदलते हैं तो मॉडल को सरलता की ओर धकेलने का दबाव बदलता है।

यदि आप इसे किसी भी दिशा में गलत चुनते हैं, तो प्रोडक्शन में समस्या होगी:

• बहुत कम: पेनल्टी इतनी कमजोर है कि मायने ही नहीं रखती। मॉडल ओवरफिट करता है, जैसे कि कोई रेग्युलराइज़ेशन ही न हो।
• बहुत अधिक: पेनल्टी हावी हो जाती है। मॉडल इतना बाधित हो जाता है कि वह डेटा में असली पैटर्न समझ ही नहीं पाता। यह अंडरफिटिंग है।

सही मान बीच में कहीं होता है, और इसका कोई सार्वभौमिक जवाब नहीं है। यह आपके डेटा, मॉडल, और शोर की मात्रा पर निर्भर करता है।

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

scikit-learn में, RidgeCV और LassoCV यह स्वचालित रूप से कर सकते हैं - वे alpha के मूल्यों की ग्रिड पर क्रॉस-वैलिडेशन चलाते हैं और आपके लिए सर्वश्रेष्ठ चुनते हैं।

from sklearn.linear_model import RidgeCV

model = RidgeCV(alphas=[0.01, 0.1, 1.0, 10.0], cv=5)
model.fit(X_train, y_train)

print(model.alpha_)

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

निष्कर्ष

रेग्युलराइज़ेशन वह तरीका है जिससे आप मॉडल को अपनी ही चतुराई का शिकार होने से बचाते हैं।

यह जटिलता पर दंड लगाता है, जिससे मॉडल ऐसे समाधान ढूँढने को मजबूर होता है जो केवल प्रशिक्षण डेटा रटने के बजाय सामान्यीकरण करें। L2 आपके सभी फीचर्स को रखेगा और उनके प्रभाव को कम करेगा। L1 अप्रासंगिक फीचर्स को हटा देगा। इलैस्टिक नेट दोनों को जोड़ता है। और रेखीय मॉडल, लॉजिस्टिक रिग्रेशन, न्यूरल नेटवर्क और एन्सेम्बल मॉडलों में, यही विचार अलग-अलग रूपों में दिखता है, और इसे हमेशा “रेग्युलराइज़ेशन” नहीं कहा जाता।

सबसे महत्वपूर्ण है वह तकनीक जिसे आप चुनते हैं और वह स्ट्रेंथ जो आप सेट करते हैं। इसलिए, आपको करना यह है कि प्रयोग करें। अलग-अलग तरीकों को अलग-अलग पैरामीटर मानों के साथ आज़माएँ। बस एक चुनकर आगे न बढ़ें।

आपका डेटा बताएगा कि क्या काम करता है।

यदि आप और रेग्युलराइज़ेशन तकनीकों को क्रिया में देखना चाहते हैं, तो हमारे Machine Learning Scientist in Python ट्रैक में नामांकित हों। इसमें 85 घंटे की सामग्री है जो आपको नौकरी के लिए तैयार कर देगी।