लाइनियर रिग्रेशन के लिए नॉर्मल इक्वेशन ट्यूटोरियल

ज्यादातर समस्याओं को कई तरीकों से हल किया जा सकता है। उदाहरण के लिए, अगर हमें कमरे के एक छोर से दूसरे छोर तक जाना हो, तो हम कमरे के चारों ओर चलते हुए सामने वाले हिस्से तक पहुँच सकते हैं, या सीधे बीच से कट कर जा सकते हैं।

नॉर्मल इक्वेशन इसी विचार पर ज़ोर देता है। यह किसी समस्या को हल करने का एक और तरीका है। कौन सी समस्या? इसका विवरण हम आगे के भाग में करेंगे। अभी के लिए बस इतना जानना पर्याप्त है कि कुछ शर्तों में लाइनियर रिग्रेशन लागू करते समय यह एक प्रभावी तरीका है जो आपका काफी समय बचा सकता है।

आइए गहराई से समझते हैं…

नॉर्मल इक्वेशन क्या है?

नॉर्मल इक्वेशन एक क्लोज़्ड-फॉर्म समाधान है, जिसका उपयोग ऑर्डिनरी लीस्ट स्क्वेयर्स लाइनियर रिग्रेशन के कॉस्ट फ़ंक्शन को न्यूनतम करने वाले θ के मान खोजने के लिए किया जाता है। इसे इस तरह भी कहा जा सकता है कि यह लॉस फ़ंक्शन को न्यूनतम करने वाले गुणांक (coefficients) खोजने का विश्लेषणात्मक तरीका है। दोनों विवरण सही हैं, लेकिन इनका अर्थ वास्तव में क्या है? 

लाइनियर रिग्रेशन इनपुट फीचर्स के वेटेड सम में एक बायस टर्म जोड़कर y_hat की भविष्यवाणी करता है। गणितीय रूप से इसे इस प्रकार लिखा जा सकता है:

जहाँ θ पैरामीटर्स को दर्शाता है और n फीचर्स की संख्या है।

मूल रूप से, ऊपर दिए गए समीकरण में θ और x का डॉट प्रोडक्ट लिया जा रहा है और उसका सम किया जा रहा है। इसलिए इसे अधिक संक्षेप में इसके वेक्टराइज़्ड रूप में दर्शाया जा सकता है:

h(θ) हाइपोथेसिस फ़ंक्शन है।

इस अनुमानित टार्गेट फ़ंक्शन के साथ, हम अपने मॉडल से पूर्वानुमान कर सकते हैं। यह निर्धारित करने के लिए कि हमारे मॉडल ने अच्छी तरह सीखा है या नहीं, प्रशिक्षण डेटा पर इसके प्रदर्शन को मापना महत्वपूर्ण है। इसके लिए हम एक लॉस फ़ंक्शन की गणना करते हैं। प्रशिक्षण प्रक्रिया का लक्ष्य ऐसे theta (θ) के मान खोजना है जो लॉस फ़ंक्शन को न्यूनतम करें।

हम अपने लॉस फ़ंक्शन को गणितीय रूप से इस प्रकार दर्शा सकते हैं:

ऊपर दिए गए समीकरण में theta (θ) एक n + 1 आयामी वेक्टर है, और हमारा लॉस फ़ंक्शन उस वेक्टर का फ़ंक्शन है। फलस्वरूप, लॉस फ़ंक्शन J का आंशिक अवकलन θ_j के हर पैरामीटर के सापेक्ष लेना पड़ता है। ये सभी शून्य के बराबर होने चाहिए। इस प्रक्रिया का पालन करते हुए और θ_0 से θ_n तक सभी मानों के लिए हल करने पर ऐसे θ प्राप्त होते हैं जो लॉस फ़ंक्शन को न्यूनतम करते हैं।

ऊपर बताई प्रक्रिया से θ_0 से θ_n तक पैरामीटर्स के समाधान तक पहुँचना अत्यंत विस्तृत व्युत्पत्ति की मांग करता है। सौभाग्य से, एक तेज़ समाधान मौजूद है।

नॉर्मल इक्वेशन के सूत्र पर नज़र डालें:

जहाँ:

θ → लॉस फ़ंक्शन को न्यूनतम करने वाले पैरामीटर्स X → प्रत्येक इंस्टेंस के इनपुट फीचर मान y → प्रत्येक इंस्टेंस के आउटपुट मानों का वेक्टर

नॉर्मल इक्वेशन बनाम ग्रेडिएंट डिसेंट

हालाँकि दोनों तरीकों का लक्ष्य लॉस फ़ंक्शन को न्यूनतम करने वाले theta (θ) खोजना है, लेकिन इनका तरीका एक-दूसरे से काफी अलग है।

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

ग्रेडिएंट डिसेंट

ग्रेडिएंट डिसेंट मशीन लर्निंग में सबसे अधिक उपयोग किए जाने वाले एल्गोरिदम में से एक है। इसका उपयोग इटरेटिव तरीके से ऐसे theta (θ) खोजने के लिए किया जाता है जो लॉस फ़ंक्शन को न्यूनतम करें।

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

यह प्रक्रिया तब तक दोहराई जाती है जब तक कि लॉस फ़ंक्शन के न्यूनतम पर अभिसरण न हो जाए।

ये कैसे अलग हैं?

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

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

नॉर्मल इक्वेशन कब उपयोग करें, यह कैसे समझें

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

जब हमारे डेटासेट में फीचर्स की संख्या बड़ी होती है, तो नॉर्मल इक्वेशन की गणना कम्प्यूटेशनली चुनौतीपूर्ण हो जाती है। इसका कारण यह है कि पैरामीटर्स θ के लिए हल करने के लिए (X’ X)^-1 पद की गणना करनी होती है। X’ X निकालने पर n x n का मैट्रिक्स बनता है, और अधिकांश कंप्यूटर इम्प्लीमेंटेशनों में मैट्रिक्स को इनवर्ट करने की जटिलता मैट्रिक्स के आयाम के घन के अनुरूप बढ़ती है। इसका मतलब है कि इनवर्स ऑपरेशन O(n^3) रनटाइम जटिलता में चलता है, जो n बहुत बड़ा होने पर नॉर्मल इक्वेशन को अत्यंत धीमा बना देता है — time complexity के बारे में और जानें।

इसलिए, जब डेटासेट में फीचर्स की संख्या बड़ी हो, तो ग्रेडिएंट डिसेंट का उपयोग करना बेहतर होता है। एंड्रयू एनजी, जो मशीन लर्निंग और AI के प्रमुख विशेषज्ञ हैं, सुझाव देते हैं कि जब फीचर्स की संख्या n, 10,000 से अधिक हो, तो आपको ग्रेडिएंट डिसेंट पर विचार करना चाहिए। 10,000 फीचर्स या उससे कम के लिए, आप नॉर्मल इक्वेशन जैसे विश्लेषणात्मक तरीके से बेहतर लाभ में रह सकते हैं क्योंकि इसमें लर्निंग रेट चुनने की आवश्यकता नहीं होती, यानी ट्यून करने के लिए एक हाइपरपैरामीटर कम हो जाता है। हालाँकि, यह कहना उचित होगा कि R या Python जैसी भाषाएँ वास्तव में ऑर्डिनरी लीस्ट स्क्वेयर्स लाइनियर रिग्रेशन के गुणांक खोजने के लिए QR decomposition का उपयोग करती हैं, क्योंकि QR decomposition नॉर्मल इक्वेशन की तुलना में संख्यात्मक रूप से अधिक स्थिर और कुशल है। 

Python में नॉर्मल इक्वेशन (स्क्रैच से)

आइए इस इक्वेशन का परीक्षण करने के लिए एक रिग्रेशन समस्या जनरेट करें:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_regression

# Generate a regression problem
X, y = make_regression(
    n_samples=100,
    n_features=2,
    n_informative=2,
    noise = 10,
    random_state=25
    )

# Visualize feature at index 1 vs target
plt.subplots(figsize=(8, 5))
plt.scatter(X[:, 1], y, marker='o')
plt.xlabel("Feature at Index 1")
plt.ylabel("Target")
plt.show()

यहाँ हम नॉर्मल इक्वेशन लागू करेंगे:

# adds x0 = 1 to each instance
X_b = np.concatenate([np.ones((len(X), 1)), X], axis=1)
# calculate normal equation
theta_best = np.linalg.inv(X_b.T.dot(X_b)).dot(X_b.T).dot(y)
# best values for theta
intercept, *coef = theta_best
print(f"Intercept: {intercept}\n\
Coefficients: {coef}")

Intercept: 0.35921242677977794
Coefficients: [6.129199175400593, 96.44309685893134]

आइए अपने मॉडल को एक प्रेडिक्शन करके परखें:

# making a new sample
new_sample = np.array([[-2, 0.25]])
# adding a bias term to the instance
new_sample_b = np.concatenate([np.ones((len(new_sample), 1)), new_sample], axis=1)
# predicting the value of our new sample
new_sample_pred = new_sample_b.dot(theta_best)
print(f"Prediction: {new_sample_pred}")
Prediction: [12.21158829]

जब भी आप किसी मशीन लर्निंग एल्गोरिदम को स्क्रैच से लागू करते हैं, तो अपने समाधान को वैलिडेट करने का एक तरीका होना उपयोगी होता है; Scikit-learn Python में सबसे लोकप्रिय मशीन लर्निंग लाइब्रेरीज़ में से एक है। इसमें कई एल्गोरिदम के इम्प्लीमेंटेशन मौजूद हैं, जिनमें लाइनियर रिग्रेशन भी शामिल है, जिसका उपयोग हम अपने नॉर्मल इक्वेशन को वैलिडेट करने के लिए करेंगे।

from sklearn.linear_model import LinearRegression

lr = LinearRegression()
lr.fit(X, y)

print(f"Intercept: {lr.intercept_}\n\
Coefficients: {lr.coef_}")
print(f"Prediction: {lr.predict(new_sample)}")

Intercept: 0.3592124267797807
Coefficients: [ 6.12919918 96.44309686]
Prediction: [12.21158829]

समाधान लगभग समान हैं, इसलिए हम पुष्टि कर सकते हैं कि हमारा समाधान सही है।