Machine Learning Academy · पाठ

लागत फलन और न्यूनतम वर्ग

शिक्षार्थी माध्य वर्ग त्रुटि की गणना करेंगे, लागत सतह का दृश्यांकन करेंगे और समझेंगे कि त्रुटि को न्यूनतम करने से सर्वोत्तम-फिट पैरामीटर क्यों मिलते हैं।

पाठ 2, कुल 4 में से12 चरण

लागत फलन और न्यूनतम वर्ग, CoddyKit पर Machine Learning Academy का एक निःशुल्क पाठ है। यह 4 में से 2वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Machine Learning Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Machine Learning Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

रेखा को 'श्रेष्ठ' क्या बनाता है?

Data points के scatter plot को देखते हुए, अनगिनत रेखाएँ data के बीच से या उसके पास से गुजर सकती हैं। प्रश्न यह है: इनमें से श्रेष्ठ रेखा कौन-सी है? हमें 'श्रेष्ठ' की एक औपचारिक गणितीय परिभाषा चाहिए, जिसे हम एल्गोरिदम के ज़रिए optimise कर सकें।

उत्तर है cost function (जिसे loss function या objective function भी कहा जाता है)—एक ऐसी संख्या जो सभी training examples पर मॉडल के पूर्वानुमान कितने गलत हैं, यह मापती है। श्रेष्ठ रेखा वह है जो cost function को minimise करती है। इससे मॉडल training एक mathematical optimisation problem में बदल जाती है।

Mean Squared Error: मानक cost function

Regression के लिए सबसे सामान्य cost function Mean Squared Error (MSE) है। प्रत्येक training example के लिए आप residual (actual minus predicted) निकालते हैं, उसका square करते हैं, फिर सभी examples पर उसका average लेते हैं:

MSE = (1/n) × Σ(yᵢ - ŷᵢ)²

Square करने के दो महत्वपूर्ण प्रभाव होते हैं: इससे सभी errors धनात्मक हो जाते हैं (इसलिए धनात्मक और ऋणात्मक errors एक-दूसरे को रद्द नहीं करते), और यह बड़े errors को छोटे errors की तुलना में अधिक दंडित करता है (10 का residual cost में 10 नहीं, बल्कि 100 योगदान देता है)। इसका अर्थ है कि MSE मॉडल को बड़ी गलतियों से बचने के लिए प्रेरित करता है।

import numpy as np

y_actual = np.array([250000, 300000, 350000, 200000, 400000])
y_pred   = np.array([240000, 320000, 330000, 210000, 380000])

# Compute MSE manually
residuals = y_actual - y_pred
squared_residuals = residuals ** 2
mse = squared_residuals.mean()

print('Residuals:', residuals)
print('Squared residuals:', squared_residuals)
print(f'MSE: {mse:,.0f}')
print(f'RMSE (interpretable): ${np.sqrt(mse):,.0f}')

Errors का square क्यों करें?

आप सोच सकते हैं: residuals के square करने के बजाय उनके absolute values का average (MAE) क्यों न लें? दोनों मान्य cost functions हैं, लेकिन MSE के कुछ गणितीय लाभ हैं:

MSE हर जगह differentiable है, जो gradient-based optimisation के लिए आवश्यक है।
Squared errors MSE surface को smooth bowl बनाते हैं, जिसमें एक unique global minimum होता है; यह कई local minima वाले कुछ cost functions से अलग है।
MSE का closed-form algebraic solution होता है, इसलिए हम iterative search के बिना optimal parameters सीधे compute कर सकते हैं।

Mean Absolute Error (MAE) outliers के प्रति अधिक robust होता है और व्यवहार में अक्सर इसे प्राथमिकता दी जाती है, लेकिन least-squares regression को समझने के लिए MSE शुरुआती बिंदु है।

import numpy as np
from sklearn.metrics import mean_squared_error, mean_absolute_error

y_actual = np.array([1.0, 2.0, 3.0, 4.0, 100.0])  # note the outlier
y_pred   = np.array([1.1, 2.0, 3.1, 4.0, 4.0])    # miss the outlier

mse = mean_squared_error(y_actual, y_pred)
mae = mean_absolute_error(y_actual, y_pred)

print(f'MSE: {mse:.2f}  -> heavily penalises the outlier (100 vs 4)')
print(f'MAE: {mae:.2f}  -> less sensitive to the outlier')
# MSE amplifies the big miss much more than MAE

Cost surface: optimisation को समझना

एक 2D space की कल्पना करें, जिसमें एक axis ढलान m और दूसरी intercept b हो। (m, b) के प्रत्येक combination के लिए हम training data पर MSE compute कर सकते हैं। इसका परिणाम एक cost surface होता है—कटोरे के आकार की 3D सतह, जिसमें कटोरे का सबसे निचला बिंदु वह optimal (m, b) है जो MSE को minimise करता है।

MSE वाले linear regression के लिए यह surface एक perfect convex paraboloid होती है—इसमें ठीक एक minimum होता है, जो सुनिश्चित करता है कि optimisation हमेशा globally best parameters खोज लेगा। non-convex loss surfaces वाले अधिक जटिल models की तुलना में यह एक महत्वपूर्ण सैद्धांतिक लाभ है।

import numpy as np
import matplotlib.pyplot as plt

# Simple 1-feature dataset
np.random.seed(42)
x = np.array([1, 2, 3, 4, 5], dtype=float)
y = np.array([2.1, 4.0, 5.9, 8.1, 10.0])

# Compute MSE for a grid of (slope, intercept) values
slopes = np.linspace(0, 4, 50)
intercepts = np.linspace(-3, 3, 50)
MSE = np.zeros((50, 50))

for i, m in enumerate(slopes):
    for j, b in enumerate(intercepts):
        y_pred = m * x + b
        MSE[j, i] = ((y - y_pred) ** 2).mean()

# Minimum MSE occurs at the true parameters (~m=2, b=0)
print('Minimum MSE:', MSE.min().round(3))
print('At grid position:', np.unravel_index(MSE.argmin(), MSE.shape))

Ordinary Least Squares solution

Ordinary Least Squares (OLS) वह closed-form mathematical solution है जो एक ही calculation में MSE को minimise करने वाली slope और intercept खोजता है—किसी iteration की आवश्यकता नहीं होती। Simple linear regression (एक feature) के लिए formulas हैं:

m = Σ(xᵢ - x̄)(yᵢ - ȳ) / Σ(xᵢ - x̄)²

b = ȳ - m × x̄

इन formulas में training data के केवल means, sums और products शामिल होते हैं। स्किकिट-लर्न का LinearRegression इस solution के generalised matrix form का उपयोग करता है, जो किसी भी संख्या में features को संभालता है।

import numpy as np

x = np.array([1, 2, 3, 4, 5], dtype=float)
y = np.array([2.1, 4.0, 5.9, 8.1, 10.0])

# OLS closed-form solution
x_mean, y_mean = x.mean(), y.mean()

numerator = ((x - x_mean) * (y - y_mean)).sum()
denominator = ((x - x_mean) ** 2).sum()

m = numerator / denominator
b = y_mean - m * x_mean

print(f'Optimal slope (m): {m:.4f}')       # ~2.0
print(f'Optimal intercept (b): {b:.4f}')   # ~0.0
print(f'MSE at optimal params: {((y - (m*x+b))**2).mean():.4f}')

Multiple features के लिए Normal Equation

जब आपके पास कई features हों, तो OLS matrix algebra का उपयोग करके Normal Equation तक generalise होता है:

w = (XᵀX)⁻¹ Xᵀy

यहाँ X feature matrix है (जिसमें bias के लिए ones का एक column होता है), y target vector है और w optimal weights का vector है। LinearRegression().fit() को call करने पर स्किकिट-लर्न internally ठीक यही compute करता है।

Normal Equation छोटे datasets (लगभग 10,000 features तक) के लिए तेज़ है, लेकिन बहुत बड़े datasets के लिए धीमा है, क्योंकि matrix inverse compute करना O(n³) operation है। बहुत बड़े datasets के लिए gradient descent को प्राथमिकता दी जाती है।

import numpy as np

# Multiple features: X has columns [1, sqft, bedrooms]
X_raw = np.array([[1000, 3], [1500, 4], [800, 2], [2000, 5]], dtype=float)
X = np.column_stack([np.ones(4), X_raw])  # add bias column
y = np.array([200000, 300000, 160000, 380000], dtype=float)

# Normal Equation: w = (X^T X)^{-1} X^T y
w = np.linalg.inv(X.T @ X) @ X.T @ y

print(f'Bias (intercept): {w[0]:,.0f}')
print(f'Sqft coefficient: {w[1]:.2f}')
print(f'Bedrooms coef:   {w[2]:,.0f}')

# Verify: prediction for a 1200 sqft, 3 bed house
pred = w[0] + w[1]*1200 + w[2]*3
print(f'Prediction: ${pred:,.0f}')

Gradient Descent: एक वैकल्पिक optimiser

बहुत बड़े datasets या लाखों parameters वाले models (जैसे neural networks) के लिए Normal Equation बहुत धीमा है। Gradient Descent एक iterative विकल्प है: cost surface पर किसी random point से शुरू करें, gradient (cost surface की slope) compute करें और ढलान की दिशा में एक छोटा कदम लें। इस प्रक्रिया को तब तक दोहराएँ, जब तक आप सबसे निचले बिंदु तक न पहुँच जाएँ।

Learning rate step size को नियंत्रित करता है। यह बहुत बड़ा हो तो आप minimum से आगे निकल जाएँगे; बहुत छोटा हो तो convergence बेहद धीमा होगा। Gradient descent deep learning training की नींव है और neural network को train करते समय आप इसी algorithm का implicit रूप से उपयोग करेंगे।

import numpy as np

# Gradient descent for linear regression
x = np.array([1, 2, 3, 4, 5], dtype=float)
y = np.array([2.1, 4.0, 5.9, 8.1, 10.0])

m, b = 0.0, 0.0   # start at zero
lr = 0.02         # learning rate

for epoch in range(500):
    y_pred = m * x + b
    residuals = y_pred - y
    # Gradients of MSE w.r.t. m and b
    grad_m = (2/len(x)) * (residuals * x).sum()
    grad_b = (2/len(x)) * residuals.sum()
    m -= lr * grad_m
    b -= lr * grad_b

print(f'Learned slope: {m:.4f}')      # ~2.0
print(f'Learned intercept: {b:.4f}')  # ~0.0

R-Squared: fit की गुणवत्ता

R² (R-squared), जिसे coefficient of determination भी कहा जाता है, यह मापता है कि y में मौजूद variance का कितना भाग मॉडल द्वारा explain किया गया है। इसका मान 0 से 1 तक होता है (बहुत खराब मॉडल के लिए यह negative भी हो सकता है):

R² = 1.0 — perfect predictions; रेखा पूरी variability को explain करती है।
R² = 0.0 — मॉडल हमेशा y का mean predict करने से बेहतर काम नहीं करता।
R² = 0.8 — मॉडल y में मौजूद variance के 80% को explain करता है।

R² regression models के मूल्यांकन का primary metric है, क्योंकि MSE के विपरीत यह scale-independent होता है और इसे हमेशा proportion के रूप में interpret किया जाता है।

import numpy as np
from sklearn.metrics import r2_score

y_actual = np.array([200, 250, 300, 350, 400], dtype=float)
y_pred_good = np.array([195, 255, 305, 345, 402], dtype=float)  # tight fit
y_pred_bad  = np.array([300, 300, 300, 300, 300], dtype=float)  # always predict mean

print(f'Good model R2: {r2_score(y_actual, y_pred_good):.3f}')  # close to 1.0
print(f'Baseline R2:   {r2_score(y_actual, y_pred_bad):.3f}')   # close to 0.0

# Manual calculation
ss_res = ((y_actual - y_pred_good)**2).sum()
ss_tot = ((y_actual - y_actual.mean())**2).sum()
print(f'Manual R2: {1 - ss_res/ss_tot:.3f}')

स्किकिट-लर्न के साथ cost का मूल्यांकन

स्किकिट-लर्न sklearn.metrics में सभी standard regression metrics उपलब्ध कराता है। आप उन्हें functions के रूप में import करते हैं, जो दो arrays—actual values और predicted values—लेकर एक scalar score लौटाते हैं।

Metrics की गणना हमेशा test set पर करें, training set पर नहीं। Training MSE बताता है कि मॉडल उस data पर कितना अच्छा fit बैठता है जिस पर उसे train किया गया है, इसलिए वह हमेशा test MSE से कम होता है। Test MSE generalisation performance का ईमानदार अनुमान है।

from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
import numpy as np

np.random.seed(42)
X = np.random.randn(200, 1)
y = 3 * X.ravel() + 2 + np.random.randn(200) * 0.5

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
model = LinearRegression().fit(X_train, y_train)
y_pred = model.predict(X_test)

print(f'Test MSE:  {mean_squared_error(y_test, y_pred):.4f}')
print(f'Test RMSE: {mean_squared_error(y_test, y_pred, squared=False):.4f}')
print(f'Test MAE:  {mean_absolute_error(y_test, y_pred):.4f}')
print(f'Test R2:   {r2_score(y_test, y_pred):.4f}')

MSE सही loss न होने पर

Regression के लिए MSE default है, लेकिन यह हमेशा सबसे अच्छा विकल्प नहीं होता:

यदि आपके target में outliers हैं, तो MSE उनके प्रभाव को बहुत बढ़ा देता है। Robustness के लिए Huber loss या MAE का उपयोग करें।
यदि absolute errors की तुलना में relative errors आपके लिए अधिक महत्वपूर्ण हैं (जैसे $100 और $1,000,000 दोनों के products की sales का पूर्वानुमान लगाना), तो MSLE (Mean Squared Log Error) का उपयोग करें।
Time-series forecasting के लिए MAPE (Mean Absolute Percentage Error) जैसे domain-specific metrics अक्सर अधिक आसानी से interpret किए जा सकते हैं।

Loss function एक design decision है, जो यह निर्धारित करता है कि आपकी विशिष्ट समस्या के लिए किस प्रकार के errors सबसे अधिक महत्वपूर्ण हैं।

त्वरित जाँच

इस पाठ में दिए गए Python के साथ Machine Learning की अवधारणाओं की अपनी समझ जाँचें।

इंटरैक्टिव पाठ में इसका उत्तर दें

पाठ का पुनरावलोकन

इस पाठ में आपने सीखा: MSE सभी training examples के squared residuals का average लेकर कुल prediction error को मापता है, OLS solution Normal Equation का उपयोग करके एक ही calculation में exact optimal slope और intercept खोजता है, और R-squared यह मापता है कि मॉडल variance के किस proportion को explain करता है और यह scale-independent होता है। आगे हम वास्तविक model को train करने, उसके coefficients की जाँच करने और उसे अलग रखे गए test set पर evaluate करने के लिए स्किकिट-लर्न के LinearRegression का उपयोग करेंगे।

शुरुआत निःशुल्क

एआई शिक्षक के साथ Python सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 30
पाठ: 120

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “लागत फलन और न्यूनतम वर्ग” पाठ निःशुल्क है?

हाँ—“लागत फलन और न्यूनतम वर्ग” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Machine Learning Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Machine Learning Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“लागत फलन और न्यूनतम वर्ग” में मैं क्या सीखूँगा?

शिक्षार्थी माध्य वर्ग त्रुटि की गणना करेंगे, लागत सतह का दृश्यांकन करेंगे और समझेंगे कि त्रुटि को न्यूनतम करने से सर्वोत्तम-फिट पैरामीटर क्यों मिलते हैं। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Machine Learning Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Machine Learning Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Machine Learning Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 2वाँ पाठ है।

“लागत फलन और न्यूनतम वर्ग” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस Machine Learning Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Machine Learning Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

रेखा का समीकरण: ढाल, अंतःखंड और पूर्वानुमान
लागत फलन और न्यूनतम वर्ग
scikit-learn से रैखिक प्रतिगमन का प्रशिक्षण
बहु रैखिक प्रतिगमन और फ़ीचर महत्त्व

← Machine Learning Academy पर वापस जाएँ