रेखा का समीकरण: ढाल, अंतःखंड और पूर्वानुमान
शिक्षार्थी y=mx+b सूत्र दोहराएँगे, वास्तविक डेटा पर प्रतिगमन रेखा बनाएँगे और समझेंगे कि मॉडल इनपुट को आउटपुट में कैसे बदलता है।
रेखा का समीकरण: ढाल, अंतःखंड और पूर्वानुमान, CoddyKit पर Machine Learning Academy का एक निःशुल्क पाठ है। यह 4 में से 1वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Machine Learning Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Machine Learning Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
डेटा में रैखिक संबंध
वास्तविक दुनिया के कई संबंध लगभग रैखिक होते हैं: जैसे-जैसे घर का क्षेत्रफल बढ़ता है, घर की कीमत उसी अनुपात में बढ़ती है; विज्ञापन पर खर्च बढ़ने पर बिक्री भी बढ़ती है। Linear regression डेटा के लिए सबसे उपयुक्त सीधी रेखा खोजकर इन संबंधों का मॉडल बनाता है।
एल्गोरिदम पर काम करने से पहले आपको उस गणितीय वस्तु को गहराई से समझना होगा जिसे वह खोजने का प्रयास करता है: रेखा का समीकरण। हर linear regression मॉडल अंततः 2D में एक रेखा या अधिक आयामों में एक hyperplane होता है, और उसे परिभाषित करने वाले दो पैरामीटर — slope और intercept — आपके हल किए जा रहे प्रश्न के लिए अर्थपूर्ण व्याख्याएँ रखते हैं।
समीकरण y = mx + b
2D में किसी रेखा का समीकरण y = mx + b होता है, जहाँ:
- y — dependent variable (जिसकी हम भविष्यवाणी करना चाहते हैं, जैसे घर की कीमत)
- x — independent variable या feature (जैसे घर का क्षेत्रफल)
- m — slope: x में हर एक इकाई की वृद्धि पर y कितना बदलता है
- b — intercept: x के शून्य होने पर y का मान
मशीन लर्निंग के संकेत-लेखन में इसे अक्सर ŷ = w₁x + w₀ या ŷ = θ₁x + θ₀ लिखा जाता है, जहाँ w या θ वे weights (पैरामीटर) हैं जिन्हें मॉडल सीखता है।
import numpy as np
import matplotlib.pyplot as plt
# Define a line: y = 2x + 5
m = 2.0 # slope
b = 5.0 # intercept
x = np.linspace(0, 10, 100)
y = m * x + b # vectorised — computes all 100 points at once
plt.plot(x, y, color='blue', linewidth=2)
plt.xlabel('x (square footage / 100)')
plt.ylabel('y (price in $1000s)')
plt.title('Line: y = 2x + 5')
plt.grid(True, alpha=0.3)
plt.show()Slope की व्याख्या
slope m परिवर्तन की दर बताता है: x में हर एक इकाई की वृद्धि पर y, m इकाइयों से बदलता है। चिह्न महत्वपूर्ण है: धनात्मक slope का अर्थ है कि x और y साथ-साथ बढ़ते या घटते हैं (धनात्मक correlation), जबकि ऋणात्मक slope का अर्थ है कि वे विपरीत दिशाओं में बदलते हैं।
ऐसे घर-कीमत मॉडल में जहाँ x घर का क्षेत्रफल और y डॉलर में कीमत है, 150 का slope बताता है कि हर अतिरिक्त वर्ग फुट से अनुमानित कीमत में $150 जुड़ते हैं। यही स्पष्ट व्याख्या linear regression की सबसे बड़ी खूबियों में से एक है — आप ठीक-ठीक समझा सकते हैं कि भविष्यवाणी को कौन-सी चीज़ प्रभावित कर रही है।
import numpy as np
# Example: house price model
# y = 150 * sqft + 50000
def predict_price(sqft, slope=150, intercept=50000):
return slope * sqft + intercept
print('Price for 1000 sqft:', predict_price(1000)) # $200,000
print('Price for 1500 sqft:', predict_price(1500)) # $275,000
print('Price for 2000 sqft:', predict_price(2000)) # $350,000
# Each 500 sqft increase adds:
delta = predict_price(1500) - predict_price(1000)
print(f'Adding 500 sqft increases price by: ${delta:,}')Intercept की व्याख्या
intercept b, x के शून्य होने पर y का मान होता है। यह ऊर्ध्वाधर अक्ष पर रेखा को एक निश्चित y-मान पर टिकाता है। Intercept की व्याख्या सावधानी से करनी चाहिए — कभी-कभी इसका भौतिक अर्थ होता है और कभी-कभी नहीं।
घर की कीमत वाले उदाहरण में $50,000 का intercept यह दर्शाएगा कि शून्य वर्ग फुट वाले घर की कीमत $50,000 है, जो भौतिक रूप से अर्थहीन है। Intercept को हर संदर्भ में प्रत्यक्ष वास्तविक-अर्थ वाले मान के बजाय एक calibration constant समझना बेहतर है, जो डेटा के अनुरूप पूरी रेखा को ऊपर या नीचे खिसकाता है।
import numpy as np
import matplotlib.pyplot as plt
x = np.array([500, 800, 1000, 1200, 1500, 2000])
y = np.array([125000, 170000, 200000, 230000, 275000, 350000])
# The intercept shifts the line vertically
for intercept in [0, 50000, 100000]:
y_line = 150 * np.linspace(0, 2000, 100) + intercept
plt.plot(np.linspace(0, 2000, 100), y_line,
label=f'b = {intercept:,}')
plt.scatter(x, y, color='black', zorder=5, label='Data')
plt.xlabel('Square Footage')
plt.ylabel('Price ($)')
plt.legend()
plt.show()डेटा और Regression Line का प्लॉट बनाना
मॉडल को फिट करने से पहले हमेशा अपने डेटा का प्लॉट बनाकर यह सुनिश्चित करें कि वास्तव में रैखिक संबंध मौजूद है। यदि scatter plot में मुड़ा हुआ या गैर-रैखिक पैटर्न दिखाई दे, तो रैखिक मॉडल गलत विकल्प है। scatter plot के ऊपर फिट की गई रेखा को दिखाना, प्रशिक्षण के बाद सत्यापन का पहला चरण है।
सीबॉर्न का regplot() एक ही कॉल में confidence interval के साथ regression line की गणना करके उसे प्लॉट करता है, जिससे EDA के दौरान यह तुरंत sanity check करने का आसान तरीका बन जाता है।
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
# Simulate house price data
np.random.seed(42)
sqft = np.random.uniform(500, 3000, 100)
price = 150 * sqft + 50000 + np.random.normal(0, 20000, 100)
# Quick regression plot with seaborn
plt.figure(figsize=(8, 5))
sns.regplot(x=sqft, y=price, scatter_kws={'alpha': 0.5},
line_kws={'color': 'red', 'linewidth': 2})
plt.xlabel('Square Footage')
plt.ylabel('Price ($)')
plt.title('House Price vs Square Footage')
plt.show()रेखा से पूर्वानुमान करना
जब आपके पास एक रेखा (ढलान m और intercept b) हो, तब नए input x के लिए पूर्वानुमान करना केवल अंकगणित है: x को समीकरण में रखकर y की गणना करें। इसे inference या पूर्वानुमान कहा जाता है।
मुख्य बात यह है कि मॉडल नए input के लिए वास्तविक output नहीं जानता—वह training data से सीखे गए पैटर्न के आधार पर उसका अनुमान लगाता है। इन पूर्वानुमानों की गुणवत्ता पूरी तरह इस बात पर निर्भर करती है कि training data नए inputs का कितनी अच्छी तरह प्रतिनिधित्व करता है और वास्तविक संबंध वास्तव में कितना रैखिक है।
import numpy as np
# Learned parameters (from training, simplified here)
slope = 150.0
intercept = 52000.0
def predict(x_new, m, b):
return m * x_new + b
# Single prediction
new_house_sqft = 1800
predicted_price = predict(new_house_sqft, slope, intercept)
print(f'Predicted price for {new_house_sqft} sqft: ${predicted_price:,.0f}')
# Batch prediction (multiple houses)
houses = np.array([1000, 1200, 1500, 2000, 2500])
prices = predict(houses, slope, intercept)
for sqft, price in zip(houses, prices):
print(f'{sqft} sqft -> ${price:,.0f}')अवशेष: पूर्वानुमान और वास्तविकता के बीच का अंतर
कोई भी वास्तविक dataset किसी रेखा पर पूरी तरह नहीं बैठता। प्रत्येक data point का अवशेष वास्तविक मान और मॉडल द्वारा अनुमानित मान के बीच का अंतर होता है: residual = y_actual - y_predicted। धनात्मक अवशेष का अर्थ है कि मॉडल ने कम पूर्वानुमान लगाया; ऋणात्मक अवशेष का अर्थ है कि उसने अधिक पूर्वानुमान लगाया।
रैखिक मॉडल का मूल्यांकन और सुधार करने के लिए अवशेष मूल सामग्री का काम करते हैं। यदि अवशेषों में कोई व्यवस्थित पैटर्न दिखाई दे (जैसे, बड़े x मानों के लिए हमेशा धनात्मक), तो यह प्रमाण है कि वास्तविक संबंध गैर-रैखिक है और अधिक जटिल मॉडल की आवश्यकता है।
import numpy as np
y_actual = np.array([200000, 250000, 310000, 180000, 420000])
# Model predictions
m, b = 150.0, 52000.0
x = np.array([1000, 1300, 1700, 850, 2400])
y_pred = m * x + b
residuals = y_actual - y_pred
for i, (actual, pred, res) in enumerate(zip(y_actual, y_pred, residuals)):
print(f'House {i+1}: Actual=${actual:,} Predicted=${pred:,.0f} Residual=${res:,.0f}')
print(f'\nMean residual: ${residuals.mean():,.0f}')
print(f'Std of residuals: ${residuals.std():,.0f}')ऋणात्मक ढलान: प्रतिलोम संबंध
ऋणात्मक ढलान प्रतिलोम संबंध को दर्शाती है: जैसे-जैसे x बढ़ता है, y घटता है। उदाहरण के लिए, कार जितनी पुरानी होगी, उसका पुनर्विक्रय मूल्य उतना ही कम होगा। इसी तरह, किसी व्यवसाय के जितने अधिक प्रतिस्पर्धी होंगे, उसकी बाज़ार हिस्सेदारी उतनी ही कम होगी।
रैखिक प्रतिगमन ऋणात्मक ढलानों को स्वाभाविक रूप से संभालता है—एल्गोरिदम training data पर सबसे अच्छा फिट बैठने वाली कोई भी ढलान (धनात्मक, ऋणात्मक या शून्य) खोज लेगा। ठीक शून्य ढलान का अर्थ होगा कि x, y के बारे में कोई जानकारी नहीं देता और प्रत्येक input के लिए सबसे अच्छा पूर्वानुमान केवल y का mean होगा।
import numpy as np
import matplotlib.pyplot as plt
# Car age vs resale value (inverse relationship)
np.random.seed(0)
age = np.random.uniform(1, 15, 50)
value = -1500 * age + 25000 + np.random.normal(0, 2000, 50)
value = np.clip(value, 1000, 30000) # clip to realistic range
plt.scatter(age, value, alpha=0.6)
plt.plot([1, 15], [-1500*1+25000, -1500*15+25000],
color='red', linewidth=2, label='y = -1500x + 25000')
plt.xlabel('Car Age (years)')
plt.ylabel('Resale Value ($)')
plt.title('Inverse Relationship: Age vs Resale Value')
plt.legend()
plt.show()रेखा से हाइपरप्लेन तक
वास्तविकता में हमारे पास लगभग हमेशा केवल एक नहीं, बल्कि कई input features होते हैं। जब आप रेखा के समीकरण को कई features तक विस्तारित करते हैं, तो उच्च-आयामी space में मॉडल एक hyperplane बन जाता है:
ŷ = w₁x₁ + w₂x₂ + ... + wₙxₙ + b
प्रत्येक wᵢ संबंधित feature xᵢ के लिए अलग coefficient (weight) है। पूर्वानुमान अब भी inputs के रैखिक संयोजन और bias का योग ही होता है। यह विस्तार—रेखा से hyperplane तक—ही वह पूरा बदलाव है जो simple से multiple linear regression पर जाने पर होता है।
import numpy as np
# Multiple linear regression prediction
# y = w1*sqft + w2*bedrooms + w3*age + b
def predict_multi(features, weights, bias):
# features shape: (n_features,) or (n_samples, n_features)
return np.dot(features, weights) + bias
weights = np.array([150.0, 5000.0, -200.0]) # sqft, bedrooms, age
bias = 30000.0
# One house: 1500 sqft, 3 bedrooms, 10 years old
house = np.array([1500, 3, 10])
price = predict_multi(house, weights, bias)
print(f'Predicted price: ${price:,.0f}')
# = 150*1500 + 5000*3 + (-200)*10 + 30000 = $282,000रैखिक मॉडल में सहसंबंध बनाम कारणता
रैखिक प्रतिगमन सांख्यिकीय सहसंबंध खोजता है, कारणात्मक संबंध नहीं। आइसक्रीम की बिक्री और डूबने से होने वाली मौतों के बीच अधिक ढलान का यह अर्थ नहीं है कि आइसक्रीम डूबने का कारण है—दोनों का कारण गर्म मौसम है। मॉडल की ढलान training data में मौजूद संबंध के बारे में बताती है, अंतर्निहित कारणात्मक प्रक्रिया के बारे में नहीं।
ML मॉडल को निर्णय लेने के लिए लागू करते समय यह अंतर अत्यंत महत्वपूर्ण होता है। ऋण-चूक का पूर्वानुमान लगाने वाला मॉडल यह पा सकता है कि ज़िप कोड एक मजबूत predictor है—लेकिन निर्णय के कारक के रूप में ज़िप कोड का उपयोग नस्ली भेदभाव को दर्ज कर सकता है, वास्तविक credit risk को नहीं। हमेशा यह जांचें कि किसी feature की पूर्वानुमान क्षमता क्यों अधिक है।
स्किकिट-लर्न के लिए तैयारी
अब जब आप समझते हैं कि रेखा क्या होती है और उसके parameters का क्या अर्थ है, तो आप डेटा से optimal slope और intercept को अपने-आप सीखने के लिए स्किकिट-लर्न का उपयोग करने के लिए तैयार हैं। एल्गोरिदम सभी training examples में कुल prediction error को कम करेगा और आपके द्वारा m और b को manually tune किए बिना best-fit line खोज लेगा।
अगले पाठ में आप ठीक-ठीक सीखेंगे कि यह optimisation कैसे काम करता है—गणितीय रूप से 'best fit' का क्या अर्थ है और Mean Squared Error cost function किसी रेखा को फिट करने की प्रक्रिया को mathematical expression को minimise करने की समस्या में कैसे बदलता है।
from sklearn.linear_model import LinearRegression
import numpy as np
# scikit-learn finds the optimal slope and intercept automatically
np.random.seed(42)
sqft = np.random.uniform(500, 3000, 100).reshape(-1, 1)
price = 150 * sqft.ravel() + 50000 + np.random.normal(0, 20000, 100)
model = LinearRegression()
model.fit(sqft, price)
print(f'Learned slope (coef_): {model.coef_[0]:.1f}')
print(f'Learned intercept (b): {model.intercept_:.1f}')
print(f'Prediction for 1500 sqft: ${model.predict([[1500]])[0]:,.0f}')त्वरित जाँच
इस पाठ में दिए गए Python के साथ Machine Learning की अवधारणाओं की अपनी समझ जाँचें।
पाठ का पुनरावलोकन
इस पाठ में आपने सीखा: समीकरण y=mx+b ढलान m (परिवर्तन की दर) और intercept b (x=0 पर y-मान) वाली रेखा को परिभाषित करता है, अवशेष वास्तविक और अनुमानित मानों के बीच के अंतर को मापते हैं, और multiple linear regression रेखा को प्रत्येक feature के लिए एक weight वाले hyperplane तक विस्तारित करता है। आगे हम cost functions और least squares का अध्ययन करेंगे—वह गणितीय ढाँचा जो 'best fit' का अर्थ परिभाषित करता है और बताता है कि एल्गोरिदम optimal parameters कैसे खोजता है।
एआई शिक्षक के साथ Python सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 30
- पाठ
- 120
अक्सर पूछे जाने वाले प्रश्न
क्या “रेखा का समीकरण: ढाल, अंतःखंड और पूर्वानुमान” पाठ निःशुल्क है?
हाँ—“रेखा का समीकरण: ढाल, अंतःखंड और पूर्वानुमान” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Machine Learning Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Machine Learning Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“रेखा का समीकरण: ढाल, अंतःखंड और पूर्वानुमान” में मैं क्या सीखूँगा?
शिक्षार्थी y=mx+b सूत्र दोहराएँगे, वास्तविक डेटा पर प्रतिगमन रेखा बनाएँगे और समझेंगे कि मॉडल इनपुट को आउटपुट में कैसे बदलता है। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Machine Learning Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या Machine Learning Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Machine Learning Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 1वाँ पाठ है।
“रेखा का समीकरण: ढाल, अंतःखंड और पूर्वानुमान” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस Machine Learning Academy पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर Machine Learning Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- रेखा का समीकरण: ढाल, अंतःखंड और पूर्वानुमान
- लागत फलन और न्यूनतम वर्ग
- scikit-learn से रैखिक प्रतिगमन का प्रशिक्षण
- बहु रैखिक प्रतिगमन और फ़ीचर महत्त्व