Sklearn लीनियर रिग्रेशन: उदाहरणों के साथ एक संपूर्ण गाइड

लीनियर रिग्रेशन, उसके उद्देश्य, और scikit-learn लाइब्रेरी का उपयोग करके उसे लागू करना सीखें। व्यावहारिक उदाहरण शामिल हैं।

अद्यतन 22 जुल॰ 2026 · 10 मि॰ पढ़ना

AI के साथ खोजें

ChatGPT में खोलें Claude में खोलें Perplexity में खोलें

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

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

कमरों की संख्या के अनुसार घर की कीमत का स्कैटर प्लॉट

लीनियर रिग्रेशन और मशीन लर्निंग

घर की कीमतें निकालने जैसी तात्कालिक उपयोगिता से आगे बढ़कर, लीनियर रिग्रेशन मशीन लर्निंग में एक महत्वपूर्ण भूमिका निभाता है।

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

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

लीनियर रिग्रेशन और scikit-learn लाइब्रेरी

scikit-learn लाइब्रेरी लीनियर रिग्रेशन को लागू करना आसान बनाती है। इस लाइब्रेरी के कई फायदे हैं।

इसका इंटरफ़ेस सुसंगत है। विभिन्न एमएल एल्गोरिद्म लागू करने के लिए कोड समान रहता है।
कोड सरल है; जटिल गणित और इम्प्लीमेंटेशन विवरण एब्स्ट्रैक्ट कर दिए गए हैं। उदाहरण के लिए, ट्रेनिंग डेटा पर मॉडल फिट करने के लिए बस यह लाइन उपयोग करें: model.fit(X_train, y_train)।
यह मॉडल कोएफ़िशिएंट्स तक आसान पहुँच प्रदान करता है।
यह मॉडल के प्रदर्शन का मूल्यांकन करने के लिए बिल्ट-इन मेट्रिक्स देता है।
Pipeline का उपयोग करके स्केलिंग और फीचर चयन जैसी प्रीप्रोसेसिंग स्टेप्स के साथ लीनियर रिग्रेशन (या कोई अन्य एमएल एल्गोरिद्म) को जोड़ना आसान है।

यदि आप scikit-learn में नए हैं, तो आप हमारी Machine Learning with scikit-learn कोर्स देखकर इस Python लाइब्रेरी का प्रायोगिक परिचय ले सकते हैं।

लीनियर रिग्रेशन को समझना

जैसा कि हमने देखा, सरल लीनियर रिग्रेशन में डेटा को "बेस्ट-फिट लाइन" से मॉडल किया जाता है। इस रेखा का सूत्र है:

जहाँ m रेखा का ढलान है और b इंटरसेप्ट है।

"मल्टिपल लीनियर रिग्रेशन" एक प्रेडिक्टर से कई प्रेडिक्टर्स (कमरों की संख्या, समुद्र के निकटता, पड़ोस की औसत आय) तक के मामले को सामान्यीकृत करता है। सूत्र इस प्रकार सामान्यीकृत होता है:

जहाँ प्रत्येक x_i एक स्वतंत्र चर है और संबंधित b_i उसका कोएफ़िशिएंट है। तीन आयामों में, रेखा एक समतल में सामान्यीकृत होती है। उच्च आयामों में, समतल "हाइपरप्लेन" बन जाता है।

हम कोएफ़िशिएंट्स और इंटरसेप्ट की व्याख्या कैसे करें? इंटरसेप्ट वह पूर्वानुमानित मान है जब सभी स्वतंत्र चर 0 हों; दूसरे शब्दों में, जब प्रेडिक्टर्स का कोई योगदान न हो तो आश्रित चर का आधारभूत मान। प्रत्येक कोएफ़िशिएंट b_i यह दर्शाता है कि अन्य सभी स्वतंत्र चर स्थिर रखते हुए, x_i में एक इकाई परिवर्तन पर आश्रित चर y में कितना परिवर्तन होगा।

पर्यावरण सेट करना

scikit-learn स्थापित करना आसान है। बस यह कमांड उपयोग करें pip install scikit-learn। यदि आप कोई विशिष्ट संस्करण, जैसे 1.2.2, स्थापित करना चाहते हैं, तो कमांड में संस्करण शामिल करें: pip install scikit-learn==1.2.2. यदि आप Anaconda का उपयोग करते हैं, तो scikit-learn पहले से स्थापित होना चाहिए। यदि किसी कारण से Anaconda वितरण का उपयोग करते समय भी इसे स्थापित करने की आवश्यकता हो, तो कमांड उपयोग करें conda install scikit-learn।

scikit-learn का उपयोग करते समय कई लाइब्रेरी आवश्यक या अनुशंसित हैं। numpy लाइब्रेरी फीचर्स और लेबल स्टोर करने के लिए आवश्यक है। pandas लाइब्रेरी डेटासेट्स को लोड करने, प्रीप्रोसेसिंग और एक्सप्लोर करने के लिए अनुशंसित है।

यदि आप scikit-learn का उपयोग कर रहे हैं, तो संभवतः आप डेटा तैयारी के लिए पहले से ही pandas का उपयोग कर रहे हैं। अपने परिणामों को प्लॉट करने के लिए, आप संभवतः matplotlib या seaborn या दोनों का उपयोग करेंगे। उपरोक्त उदाहरण की तरह, इन सभी लाइब्रेरीज़ को pip install के माध्यम से स्थापित किया जा सकता है। आप एक ही कमांड से कई लाइब्रेरी भी स्थापित कर सकते हैं:

pip install scikit-learn numpy pandas matplotlib seaborn।

sklearn में लीनियर रिग्रेशन लागू करना

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

# Import libraries.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

डेटासेट लोड करना

आइए प्रसिद्ध California housing डेटासेट का उपयोग करें।

# Read in California housing dataset.
from sklearn.datasets import fetch_california_housing


housing = fetch_california_housing()

डेटा तैयार करना

डेटा को ट्रेनिंग और टेस्टिंग सेट्स में विभाजित करें। हम sklearn.model_selection से train_test_split() मेथड इम्पोर्ट करेंगे, फिर इसे टेस्ट सेट का प्रतिशत और random_state निर्धारित करते हुए कॉल करेंगे। हम सरल लीनियर रिग्रेशन भी उपयोग करेंगे, जिसमें औसत कमरों की संख्या वाले फीचर को लेंगे।

# Import train_test_split.
from sklearn.model_selection import train_test_split


# Create features X and target y.
X = pd.DataFrame(housing.data, columns=housing.feature_names)[["AveRooms"]]
y = housing.target  # Median house value in $100,000s


# Split the dataset into training (80%) and testing (20%) sets.
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

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

# Import StandardScaler.
from sklearn.preprocessing import StandardScaler

# Instantiate StandardScaler.
scaler = StandardScaler()

# Fit and transform training data.
X_train_scaled = scaler.fit_transform(X_train)

# Also transform test data.
X_test_scaled = scaler.transform(X_test)

इस कोड में, StandardScaler एक डेटा प्रीप्रोसेसिंग टूल है जो माध्य हटाकर और यूनिट वेरिएंस तक स्केल करके फीचर्स को मानकीकृत करता है। इससे स्केल में अंतर के कारण कुछ फीचर्स का मॉडल पर हावी होना रोका जा सकता है।

स्केलर को ट्रेनिंग डेटा पर fit_transform() मेथड से फिट और ट्रांसफॉर्म किया जाता है। टेस्ट डेटा को अलग से transform() मेथड से ट्रांसफॉर्म किया जाता है ताकि उसे ट्रेनिंग डेटा वाले समान फैक्टर्स से स्केल किया जाए, जिससे डेटा लीकेज रोकी जा सके।

लीनियर रिग्रेशन मॉडल को ट्रेन करना

लीनियर रिग्रेशन मॉडल बनाने के लिए sklearn.linear_model से LinearRegression() इम्पोर्ट करें। इसे कॉल करके किसी वेरिएबल को असाइन करें।

# Import LinearRegression.
from sklearn.linear_model import LinearRegression


# Instantiate linear regression model.
model = LinearRegression()

ट्रेनिंग डेटा के साथ मॉडल फिट करना सीधा है।

# Fit the model to the training data.
model.fit(X_train_scaled, y_train)

प्रेडिक्शन करना

अब जब हमने अपना मॉडल ट्रेन कर लिया है, तो टेस्ट सेट पर भविष्यवाणियाँ करेंगे।

# Make predictions on the testing data.
y_pred = model.predict(X_test_scaled)

मॉडल के प्रदर्शन का मूल्यांकन

अब जब हमने टेस्ट सेट पर भविष्यवाणियाँ कर ली हैं, तो हमें जानना होगा कि वे वास्तविकता से कितना मेल खाती हैं। रिग्रेशन एल्गोरिद्म के प्रदर्शन का मूल्यांकन करने के लिए कई मेट्रिक्स उपलब्ध हैं। सबसे आम हैं निर्धारण गुणांक (R²), मीन स्क्वायर्ड एरर (MSE), और रूट मीन स्क्वायर्ड एरर (RMSE)।

निर्धारण गुणांक, जिसे R² कहा जाता है, यह मापता है कि एक रिग्रेशन मॉडल लक्ष्य चर की वैरिएबिलिटी को कितना अच्छी तरह समझाता है। दूसरे शब्दों में, यह मापता है कि लक्ष्य चर में कितनी वैरिएबिलिटी प्रेडिक्टर्स द्वारा समझाई जाती है—इसे गुडनेस ऑफ़ फिट भी कहते हैं।

इसे और समझने के लिए, सूत्र देखें:

जहाँ yactual लक्ष्य चर के वास्तविक मान हैं, ypredicted मॉडल से प्राप्त भविष्यवाणी किए गए मान हैं, और ȳ वास्तविक मानों का औसत है। यह सूत्र हमें बताता है कि लक्ष्य चर की वैरिएंस का कितना भाग मॉडल द्वारा समझाया गया है। हर (denominator) डेटा में कुल वैरिएंस दर्शाता है, जबकि अंश (numerator) रिग्रेशन मॉडल लागू करने के बाद अनसमझाई वैरिएंस को दर्शाता है। अतः यह अनुपात मॉडल द्वारा समझाई गई वैरिएंस का प्रतिशत देता है।

R² की व्याख्या कैसे करें?

R² = 1: मॉडल लक्ष्य चर की पूरी वैरिएंस को पूरी तरह समझा देता है।
R² = 0: मॉडल कोई वैरिएंस नहीं समझाता; भविष्यवाणियाँ मात्र औसत उपयोग करने से बेहतर नहीं हैं।
R² < 0: मॉडल केवल औसत उपयोग करने से भी खराब प्रदर्शन करता है, जो खराब फिट को दर्शाता है।

कुछ मुख्य बातों पर ध्यान रखें।

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

scikit-learn के साथ निर्धारण गुणांक का उपयोग करके मॉडल का मूल्यांकन करना आसान है।

# Import metrics.
from sklearn.metrics import mean_squared_error, r2_score


# Calculate and print R^2 score.
r2 = r2_score(y_test, y_pred)
print(f"R-squared: {r2:.4f}")

R-squared: 0.0138

अन्य सामान्यतः उपयोग होने वाले मेट्रिक्स MSE (मीन स्क्वायर्ड एरर) और RMSE (रूट मीन स्क्वायर्ड एरर) हैं। ये मेट्रिक्स मापते हैं कि किसी मॉडल की भविष्यवाणियाँ वास्तविक मानों से कितनी भिन्न हैं।

MSE वास्तविक और भविष्यवाणी किए गए मानों के औसत वर्गांतर की गणना करता है:

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

इसे संबोधित करने के लिए RMSE उपयोग किया जाता है, जो बस MSE का वर्गमूल है। चूँकि RMSE लक्ष्य चर की ही इकाइयों में होता है, यह इस बात का अधिक व्याख्यायनीय माप देता है कि औसतन भविष्यवाणियाँ कितनी दूर हैं।

scikit-learn के साथ MSE और RMSE की गणना करना सरल है।

# Calculate and print MSE.
mse = mean_squared_error(y_test, y_pred)
print(f"Mean squared error: {mse:.4f}")


# Calculate and print RMSE.
rmse = mse ** 0.5
print(f"Root mean squared error: {rmse:.4f}")

Mean squared error: 1.2923
Root mean squared error: 1.1368

scikit-learn में मल्टिपल लीनियर रिग्रेशन के साथ काम करना

आइए मॉडल को केवल औसत कमरों की संख्या ही नहीं, बल्कि उपलब्ध सभी फीचर्स के साथ फिर से चलाएँ। क्या आप बेहतर या खराब परिणाम की उम्मीद करते हैं?

# Uses all features.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score


# Load data set.
housing = fetch_california_housing()


# Split into X, y.
X = pd.DataFrame(housing.data, columns=housing.feature_names)
y = housing.target  # Median house value in $100,000s
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)


# Scale the data.
scaler = StandardScaler()


X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)


# Create model and fit it to the training data.
model = LinearRegression()
model.fit(X_train_scaled, y_train)


# Make predictions.
y_pred = model.predict(X_test_scaled)


# Calculate and print errors.
r2 = r2_score(y_test, y_pred)
print(f"R-squared: {r2:.4f}")


mse = mean_squared_error(y_test, y_pred)
print(f"Mean squared error: {mse:.4f}")


rmse = mse ** 0.5
print(f"Root mean squared error: {rmse:.4f}")

R-squared: 0.5758
Mean squared error: 0.5559
Root mean squared error: 0.7456

हम देखते हैं कि केवल एक फीचर उपयोग करने की तुलना में परिणाम काफी बेहतर हैं। हालांकि, इससे यह प्रश्न उठता है कि क्या हमें सभी फीचर्स की आवश्यकता है। क्या कुछ फीचर्स अन्य की तुलना में अधिक प्रासंगिक हैं? डेटासेट से सबसे प्रासंगिक फीचर्स चुनना फीचर चयन कहलाता है।

फीचर चयन कई कारणों से महत्वपूर्ण है।

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

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

Variance Inflation Factor (VIF) एक मीट्रिक है जो प्रेडिक्टर्स के बीच मल्टिकॉलीनियरिटी का पता लगाने के लिए उपयोग होता है। प्रत्येक प्रेडिक्टर के लिए, VIF इस प्रकार निकाला जाता है:

जहाँ R_i² वह R² मान है जो प्रेडिक्टर X_i को मॉडल के अन्य सभी प्रेडिक्टर्स पर रिग्रेस करने पर प्राप्त होता है। उच्च VIF का अर्थ है कि प्रेडिक्टर अन्य वेरिएबल्स के साथ अत्यधिक सह-संबद्ध है।

VIF = 1: कोई मल्टिकॉलीनियरिटी नहीं (आदर्श स्थिति)।
VIF < 5: कम से मध्यम मल्टिकॉलीनियरिटी (आम तौर पर स्वीकार्य)।
VIF > 5: उच्च मल्टिकॉलीनियरिटी (सह-संबद्ध वेरिएबल्स को हटाने या संयोजित करने पर विचार करें)।
VIF > 10: गंभीर मल्टिकॉलीनियरिटी (वेरिएबल अनावश्यकता का प्रबल संकेत)।

# Import libraries.
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.datasets import fetch_california_housing
from statsmodels.stats.outliers_influence import variance_inflation_factor


# Load the dataset.
housing = fetch_california_housing()
X = pd.DataFrame(housing.data, columns=housing.feature_names)


# Compute the correlation matrix.
corr_matrix = X.corr()


# Identify pairs of features with high collinearity (correlation > 0.8 or < -0.8).
high_corr_features = [(col1, col2, corr_matrix.loc[col1, col2])
                     for col1 in corr_matrix.columns
                     for col2 in corr_matrix.columns
                     if col1 != col2 and abs(corr_matrix.loc[col1, col2]) > 0.8]


# Convert to a DataFrame for better visualization.
collinearity_df = pd.DataFrame(high_corr_features, columns=["Feature 1", "Feature 2", "Correlation"])
print("\nHighly Correlated Features:\n", collinearity_df)


# Compute Variance Inflation Factor (VIF) for each feature.
vif_data = pd.DataFrame()
vif_data["Feature"] = X.columns
vif_data["VIF"] = [variance_inflation_factor(X.values, i) for i in range(X.shape[1])]


# Print VIF values.
print("\nVariance Inflation Factor (VIF) for each feature:\n", vif_data)

   Highly Correlated Features:
       Feature 1  Feature 2  Correlation
   0   AveRooms  AveBedrms     0.847621
   1  AveBedrms   AveRooms     0.847621
   2   Latitude  Longitude    -0.924664
   3  Longitude   Latitude    -0.924664
  
   Variance Inflation Factor (VIF) for each feature:
          Feature         VIF
   0      MedInc   11.511140
   1    HouseAge    7.195917
   2    AveRooms   45.993601
   3   AveBedrms   43.590314
   4  Population    2.935745
   5    AveOccup    1.095243
   6    Latitude  559.874071
   7   Longitude  633.711654

आइए AveBedrms को मॉडल से हटा दें।

# Import libraries.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score


# Load California housing dataset.
housing = fetch_california_housing()


# Create DataFrame and remove "AveBedrms" feature.
X = pd.DataFrame(housing.data, columns=housing.feature_names).drop(columns=["AveBedrms"])
y = housing.target  # Median house value in $100,000s


# Split data into training and testing sets.
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)


# Scale the data (Standardization).
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)


# Create a linear regression model and train it.
model = LinearRegression()
model.fit(X_train_scaled, y_train)


# Make predictions on the test set.
y_pred = model.predict(X_test_scaled)


# Calculate performance metrics.
r2 = r2_score(y_test, y_pred)
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
# Print evaluation metrics
print(f"R-squared: {r2:.4f}")
print(f"Mean squared error: {mse:.4f}")
print(f"Root mean squared error: {rmse:.4f}")

R-squared: 0.5823
Mean squared error: 0.5473
Root mean squared error: 0.7398

परिणाम (थोड़ा) बेहतर हुए हैं।

मॉडल से अंतर्दृष्टि निकालना

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

रिग्रेशन कोएफ़िशिएंट्स को समझना

एक बार जब लीनियर रिग्रेशन मॉडल ट्रेन हो जाता है, तो कोएफ़िशिएंट्स को model.coef_ के माध्यम से एक्सेस किया जा सकता है। इंटरसेप्ट को model.intercept_ के माध्यम से एक्सेस किया जा सकता है।

जब LinearRegression() का उपयोग करके लीनियर रिग्रेशन मॉडल ट्रेन हो जाता है, तो कोएफ़िशिएंट्स को model.coef_ और इंटरसेप्ट को model.intercept_ के माध्यम से प्राप्त किया जा सकता है।

print("Intercept:", model.intercept_)


coeff_df = pd.DataFrame({"Feature": X.columns, "Coefficient": model.coef_})
print("\nFeature Coefficients:\n", coeff_df)

   Intercept: 2.0719469373788777  

   Feature Coefficients:

         Feature  Coefficient

   0     MedInc     0.725747

   1   HouseAge     0.121519

   2   Latitude    -0.943105

   3  Longitude    -0.900735

मॉडल परिणामों का सार

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

# Sort dataframe by coefficients.
coef_df_sorted = coef_df.sort_values(by="Coefficient", ascending=False)


# Create plot.
plt.figure(figsize=(8,6))
plt.barh(coef_df["Feature"], coef_df_sorted["Coefficient"], color="blue")
plt.xlabel("Coefficient Value")
plt.ylabel("Feature")
plt.title("Feature Importance (Linear Regression Coefficients)")
plt.show()

कोएफ़िशिएंट मानों के आधार पर फीचर महत्त्व का ग्राफ़

अब, रेज़िडुअल्स और रिग्रेशन फ़िट का विज़ुअलाइज़ेशन करें।

# Compute residuals.
residuals = y_test - y_pred


# Create plots.
plt.figure(figsize=(12,5))


# Plot 1: Residuals Distribution.
plt.subplot(1,2,1)
sns.histplot(residuals, bins=30, kde=True, color="blue")
plt.axvline(x=0, color='red', linestyle='--')
plt.title("Residuals Distribution")
plt.xlabel("Residuals (y_actual - y_predicted)")
plt.ylabel("Frequency")


# Plot 2: Regression Fit (Actual vs Predicted).
plt.subplot(1,2,2)
sns.scatterplot(x=y_test, y=y_pred, alpha=0.5)
plt.plot([min(y_test), max(y_test)], [min(y_test), max(y_test)], color='red', linestyle='--')  # Perfect fit line
plt.title("Regression Fit: Actual vs Predicted")
plt.xlabel("Actual Prices (in $100,000s)")
plt.ylabel("Predicted Prices (in $100,000s)")


# Show plots.
plt.tight_layout()
plt.show()

रेज़िडुअल्स और रिग्रेशन फ़िट को दर्शाने वाले प्लॉट्स

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

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

वास्तविक दुनिया के उपयोग

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

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

लीनियर रिग्रेशन कब इस्तेमाल करें

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

लीनियर रिग्रेशन कब न इस्तेमाल करें

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

निष्कर्ष

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

ट्यूटोरियल से मुख्य निष्कर्ष:

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

Python स्ट्रिंग इंटरपोलेशन पर अधिक जानकारी के लिए, DataCamp के संसाधन देखें।

सिंपल लीनियर रिग्रेशन: वह सब कुछ जो आपको जानना चाहिए - ट्यूटोरियल
R में लीनियर रिग्रेशन कैसे करें - ट्यूटोरियल
Excel में लीनियर रिग्रेशन: शुरुआती लोगों के लिए एक व्यापक गाइड - ट्यूटोरियल
R में रिग्रेशन का परिचय - कोर्स
Supervised Learning with scikit-learn - कोर्स
Scikit-Learn चीट शीट: Python मशीन लर्निंग - चीट शीट
Python में लॉजिस्टिक रिग्रेशन को समझना - ट्यूटोरियल

What is linear regression, and how does it work?

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

What are the assumptions of linear regression?

लीनियर रिग्रेशन इन मान्यताओं पर निर्भर करता है:

रैखिकता: प्रेडिक्टर्स और लक्ष्य चर के बीच संबंध रैखिक हो।
स्वतंत्रता: प्रेक्षण एक-दूसरे से स्वतंत्र हों।
होमोस्डैस्टीसिटी: सभी मूल्यों पर रेज़िडुअल्स का वेरिएंस स्थिर हो।
रेज़िडुअल्स की सामान्यता: रेज़िडुअल्स सामान्य वितरण का पालन करें।
कोई मल्टिकॉलीनियरिटी नहीं: स्वतंत्र वेरिएबल्स अत्यधिक सह-संबद्ध न हों।

Why should I scale my features before fitting a linear regression model?

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

What is multicollinearity, and how can I detect it?

मल्टिकॉलीनियरिटी वह स्थिति है जब दो या अधिक स्वतंत्र वेरिएबल्स अत्यधिक सह-संबद्ध हों, जिससे कोएफ़िशिएंट्स की व्याख्या अविश्वसनीय हो जाती है। इसे Variance Inflation Factor (VIF) का उपयोग करके पहचाना जा सकता है।

How do I evaluate a linear regression model?

मुख्य प्रदर्शन मेट्रिक्स में शामिल हैं:

R² (निर्धारण गुणांक) → यह मापता है कि मॉडल लक्ष्य चर की वैरिएंस को कितना अच्छी तरह समझाता है।
MSE (मीन स्क्वायर्ड एरर) → वास्तविक और भविष्यवाणी किए गए मानों के बीच औसत वर्ग त्रुटि को मापता है।
RMSE (रूट मीन स्क्वायर्ड एरर) → MSE का अधिक व्याख्यायनीय रूप।

विषय

Python

मशीन लर्निंग

शीर्ष DataCamp कोर्स

Track

एसोसिएट डेटा वैज्ञानिक में Python

90 घंटा

Python में डेटा विज्ञान सीखें, डेटा मैनिपुलेशन से लेकर मशीन लर्निंग तक. यह ट्रैक आपको डेटा वैज्ञानिक के रूप में सफल होने के लिए आवश्यक कौशल प्रदान करता है!

विस्तृत जानकारी देखें

कोर्स शुरू करें

course