PricingLoginStart free
Machine Learning Academy · पाठ

फ़ीचर स्केलिंग: StandardScaler और MinMaxScaler

शिक्षार्थी प्रशिक्षण डेटा पर StandardScaler और MinMaxScaler फिट करेंगे, परीक्षण डेटा को अलग से रूपांतरित करेंगे और समझेंगे कि परीक्षण डेटा पर फिट करने से डेटा रिसाव क्यों होता है।

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

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

फीचर स्केलिंग महत्वपूर्ण क्यों है

कई मशीन लर्निंग एल्गोरिदम इनपुट फीचरों के पैमाने के प्रति संवेदनशील होते हैं। यदि एक फीचर का विस्तार 0–1000 और दूसरे का 0–1 हो, तो KNN और SVM जैसे दूरी-आधारित मॉडल बड़े पैमाने वाले फीचर से अत्यधिक प्रभावित होंगे। जब फीचरों का पैमाना समान हो, तो ग्रेडिएंट डिसेंट एल्गोरिदम भी बहुत तेज़ी से अभिसरित होते हैं। Random Forest जैसे वृक्ष-आधारित मॉडल और XGBoost पैमाने से स्वतंत्र होते हैं और उन्हें स्केलिंग की आवश्यकता नहीं होती, लेकिन लगभग हर दूसरे एल्गोरिदम को इससे लाभ मिलता है।

import numpy as np

# Without scaling: 'income' dominates 'age'
X = np.array([
    [25, 50000],
    [35, 80000],
    [45, 120000]
])

# Distance between row 0 and row 1 (Euclidean)
dist = np.sqrt((25-35)**2 + (50000-80000)**2)
print('Distance dominated by income:', dist)
# age contributes 100, income contributes 900,000,000 to squared distance

StandardScaler: Z-स्कोर सामान्यीकरण

StandardScaler सूत्र z = (x - mean) / std लागू करके प्रत्येक फीचर का mean शून्य और variance एक कर देता है। इसे मानकीकरण या z-स्कोर सामान्यीकरण कहा जाता है। परिणामी मान 0 के आसपास केंद्रित होते हैं और उनकी कोई निश्चित सीमा नहीं होती। अधिकांश एल्गोरिदम के लिए StandardScaler डिफ़ॉल्ट विकल्प है, जिनमें लॉजिस्टिक प्रतिगमन, SVM और न्यूरल नेटवर्क शामिल हैं, विशेषकर तब जब फीचर वितरण लगभग गॉसियन हो।

from sklearn.preprocessing import StandardScaler
import numpy as np

X = np.array([[25, 50000], [35, 80000], [45, 120000]], dtype=float)

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

print('Scaled data:\n', X_scaled)
print('Mean per feature:', X_scaled.mean(axis=0))  # ~[0, 0]
print('Std per feature:', X_scaled.std(axis=0))    # ~[1, 1]

StandardScaler आँकड़े कैसे संग्रहीत करता है

fit() को कॉल करने के बाद StandardScaler प्रशिक्षण-सेट के आँकड़े scaler.mean_ और scaler.scale_ (मानक विचलन) में संग्रहीत करता है। नए डेटा पर transform() कॉल करने पर इन्हीं आँकड़ों का उपयोग होता है — अर्थात परीक्षण सेट को उसके अपने मापदंडों से नहीं, बल्कि प्रशिक्षण सेट के मापदंडों से स्केल किया जाता है। यही सही व्यवहार है: उत्पादन में आपको अलग-अलग नमूने एक-एक करके मिलते हैं और उन्हें प्रशिक्षण के दौरान निकाले गए आँकड़ों का उपयोग करके स्केल करना होता है।

from sklearn.preprocessing import StandardScaler
import numpy as np

X_train = np.array([[1, 200], [2, 400], [3, 600]], dtype=float)
X_test  = np.array([[4, 800]], dtype=float)

scaler = StandardScaler()
scaler.fit(X_train)  # Learn mean and std from training data ONLY

print('Learned mean:', scaler.mean_)
print('Learned scale:', scaler.scale_)

X_train_s = scaler.transform(X_train)
X_test_s  = scaler.transform(X_test)  # Uses SAME training statistics
print('Test scaled:', X_test_s)

MinMaxScaler: एक निश्चित सीमा में पुनःस्केल करना

MinMaxScaler सूत्र x_scaled = (x - x_min) / (x_max - x_min) का उपयोग करके प्रत्येक फीचर को सामान्यतः [0, 1] जैसी निर्दिष्ट सीमा में संकुचित करता है। StandardScaler के विपरीत, यह वितरण के सापेक्ष आकार को बनाए रखता है और गैर-गॉसियन डेटा के साथ अच्छी तरह काम करता है। यह बाहरी मानों के प्रति संवेदनशील है: एक अकेला अत्यधिक मान अन्य सभी मानों को शून्य या एक के पास दबा सकता है। MinMaxScaler न्यूरल नेटवर्क और छवि के पिक्सेल मानों के लिए लोकप्रिय है, जिन्हें [0, 1] तक स्केल किया जाता है।

from sklearn.preprocessing import MinMaxScaler
import numpy as np

X = np.array([[10], [20], [30], [40], [50]], dtype=float)

scaler = MinMaxScaler(feature_range=(0, 1))
X_scaled = scaler.fit_transform(X)

print('MinMax scaled:', X_scaled.flatten())
# [0.0, 0.25, 0.5, 0.75, 1.0]

# Custom range: scale to [-1, 1]
scaler2 = MinMaxScaler(feature_range=(-1, 1))
print('[-1,1] scaled:', scaler2.fit_transform(X).flatten())

RobustScaler: बाहरी मानों को संभालना

RobustScaler माध्य और मानक विचलन के बजाय माध्यिका और इंटरक्वार्टाइल रेंज (IQR) का उपयोग करके स्केल करता है। चूँकि माध्यिका और IQR चरम मानों से प्रभावित नहीं होते, इसलिए जब आपके डेटा में महत्वपूर्ण बाहरी मान हों, तब RobustScaler बेहतर विकल्प है। सूत्र है: x_scaled = (x - median) / IQR। जब आप बाहरी मानों को हटा नहीं सकते और चाहते हैं कि मॉडल को दिए जाने वाले स्केल किए गए मानों पर उनका प्रभाव न्यूनतम हो, तब RobustScaler का उपयोग करें।

from sklearn.preprocessing import RobustScaler
import numpy as np

# Data with outlier at 1000
X = np.array([[1], [2], [3], [4], [1000]], dtype=float)

from sklearn.preprocessing import StandardScaler, RobustScaler

std_s = StandardScaler().fit_transform(X)
rob_s = RobustScaler().fit_transform(X)

print('StandardScaler (outlier squishes others):')
print(std_s.flatten())
print('RobustScaler (outlier isolated):')
print(rob_s.flatten())

सही स्केलर चुनना

यहाँ एक त्वरित निर्णय-मार्गदर्शिका है: जब आपका डेटा लगभग गॉसियन हो और उसमें कोई चरम बाहरी मान न हों, तब StandardScaler का उपयोग करें — यह सबसे सुरक्षित डिफ़ॉल्ट विकल्प है। जब आपको मानों को एक निश्चित सीमा में रखना हो, जैसे इमेज डेटा या ऐसे एल्गोरिदम के लिए जिन्हें [0, 1] इनपुट चाहिए, तब MinMaxScaler का उपयोग करें। जब बाहरी मान मौजूद और अर्थपूर्ण हों, जैसे धोखाधड़ी में अचानक बढ़ोतरी वाला वित्तीय डेटा, तब RobustScaler का उपयोग करें। ट्री-आधारित मॉडल (रैंडम फ़ॉरेस्ट, XGBoost, LightGBM) के लिए स्केलिंग पूरी तरह छोड़ दें — इससे कोई लाभ नहीं होता और अनावश्यक जटिलता बढ़ती है।

from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler

# Decision helper
def pick_scaler(has_outliers, needs_fixed_range, is_tree_model):
    if is_tree_model:
        return 'No scaling needed'
    elif has_outliers:
        return 'RobustScaler'
    elif needs_fixed_range:
        return 'MinMaxScaler'
    else:
        return 'StandardScaler'

print(pick_scaler(False, False, False))  # StandardScaler
print(pick_scaler(True, False, False))   # RobustScaler
print(pick_scaler(False, True, False))   # MinMaxScaler
print(pick_scaler(False, False, True))   # No scaling needed

परीक्षण डेटा पर फिट करना: leakage का जाल

एक सामान्य गलती परीक्षण सेट पर fit_transform() चलाना है, जिससे परीक्षण डेटा से नया माध्य और मानक विचलन निकाला जाता है। यह डेटा leakage का एक रूप है, क्योंकि स्केलर परीक्षण-सेट के मानों से प्रभावित होता है। सही तरीका है: fit(X_train) → transform(X_train) → transform(X_test)। इस leakage से मिलने वाला थोड़ा-सा सटीकता सुधार भी अत्यधिक आत्मविश्वास वाले उत्पादन परिनियोजन का कारण बन सकता है, जो वास्तव में पहले न देखे गए डेटा पर विफल हो जाता है।

from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
import numpy as np

X = np.random.randn(100, 3)
y = (X[:, 0] > 0).astype(int)

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

scaler = StandardScaler()

# CORRECT: fit on train, transform both
scaler.fit(X_train)
X_train_s = scaler.transform(X_train)
X_test_s  = scaler.transform(X_test)

# WRONG (leakage):
# scaler.fit_transform(X_test)  <- never do this

पाइपलाइन के अंदर स्केलिंग

स्केलिंग leakage से बचने का सबसे साफ़ तरीका है कि स्केलर को scikit-learn की Pipeline के अंदर शामिल किया जाए। जब पाइपलाइन को cross_val_score या GridSearchCV के साथ फिट किया जाता है, तो प्रत्येक fold में स्केलर केवल उसी fold के प्रशिक्षण वाले हिस्से पर फिट होता है। फोल्ड के परीक्षण हिस्से को फिट करते समय कभी उपयोग नहीं किया जाता। यह उत्पादन के लिए तैयार तरीका है: पूर्व-प्रसंस्करण और मॉडलिंग के चरणों को एक साथ बाँध दिया जाता है, जिससे परिनियोजन केवल pipeline.predict(X_new) चलाने जितना सरल हो जाता है।

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score
from sklearn.datasets import load_iris

X, y = load_iris(return_X_y=True)

pipe = Pipeline([
    ('scaler', StandardScaler()),
    ('clf', LogisticRegression(max_iter=200))
])

# Scaler fitted only on train fold in each CV iteration
scores = cross_val_score(pipe, X, y, cv=5)
print('CV accuracy:', scores.mean().round(3))

उलटा रूपांतरण: मूल स्केल पर वापस

पूर्वानुमान करने के बाद आपको पूर्वानुमानों को मूल स्केल पर वापस बदलना पड़ सकता है — उदाहरण के लिए, लॉग-स्केल की गई कीमतों पर प्रशिक्षित घर-कीमत मॉडल को कीमतें डॉलर में देनी होंगी। StandardScaler और MinMaxScaler दोनों स्केलिंग को उलटने के लिए inverse_transform() उपलब्ध कराते हैं। केवल लक्ष्य चर पर inverse-transform करें, जब प्रशिक्षण से पहले उसे स्केल किया गया हो। विशेषताओं को सामान्यतः inverse-transform करने की आवश्यकता नहीं होती, क्योंकि मॉडल उनका आंतरिक रूप से उपयोग करता है।

from sklearn.preprocessing import StandardScaler
import numpy as np

y_train = np.array([100000, 200000, 300000, 400000], dtype=float).reshape(-1, 1)

target_scaler = StandardScaler()
y_scaled = target_scaler.fit_transform(y_train)
print('Scaled target:', y_scaled.flatten())

# After predicting in scaled space:
y_pred_scaled = np.array([[0.5]])
y_pred_original = target_scaler.inverse_transform(y_pred_scaled)
print('Prediction in original scale:', y_pred_original)

MaxAbsScaler से विरल डेटा की स्केलिंग

विरल मैट्रिक्स — जो TF-IDF वेक्टरों के साथ पाठ वर्गीकरण में सामान्य हैं — को StandardScaler या MinMaxScaler से स्केल नहीं करना चाहिए, क्योंकि केंद्रित करने से अधिकांश शून्य मान गैर-शून्य हो जाते हैं और विरलता नष्ट हो जाती है। इससे विरल भंडारण का उद्देश्य ही समाप्त हो जाता है। MaxAbsScaler प्रत्येक विशेषता को उसके अधिकतम निरपेक्ष मान से स्केल करता है, मानों को बिना केंद्रित किए [-1, 1] की सीमा में लाता है और विरलता की संरचना बनाए रखता है। TfidfVectorizer जैसे वेक्टराइज़र से प्राप्त विरल विशेषता मैट्रिक्स के साथ काम करते समय हमेशा MaxAbsScaler का उपयोग करें।

from sklearn.preprocessing import MaxAbsScaler
from scipy.sparse import csr_matrix
import numpy as np

# Simulated sparse TF-IDF matrix
X_sparse = csr_matrix(np.array([
    [0, 0.5, 0.3, 0],
    [0.8, 0, 0, 0.4],
    [0, 0.2, 0, 0.6]
]))

scaler = MaxAbsScaler()
X_scaled = scaler.fit_transform(X_sparse)
print('Scaled sparse matrix:\n', X_scaled.toarray())
# All values in [-1, 1], sparsity preserved

वास्तविक डेटा पर स्केलरों की तुलना

प्रत्येक स्केलर के व्यावहारिक प्रभाव को देखने के लिए उनके आउटपुट वितरणों की साथ-साथ तुलना करें। स्केलिंग के बाद, StandardScaler का आउटपुट लगभग N(0,1) होना चाहिए, MinMaxScaler का आउटपुट [0,1] तक फैला होना चाहिए और RobustScaler के आउटपुट की माध्यिका 0 तथा IQR 1 होना चाहिए। स्केलिंग से पहले और बाद के हिस्टोग्राम बनाने पर यह पुष्टि हो जाती है कि रूपांतरण सही ढंग से हुआ है। विश्वसनीय मॉडल प्रशिक्षण के लिए अच्छी विशेषता स्केलिंग एक आवश्यक पूर्वशर्त है, कोई वैकल्पिक अतिरिक्त सुविधा नहीं।

import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler
import numpy as np

X = np.random.exponential(scale=100, size=(200, 1))  # Skewed data

scalers = {
    'StandardScaler': StandardScaler(),
    'MinMaxScaler': MinMaxScaler(),
    'RobustScaler': RobustScaler()
}

fig, axes = plt.subplots(1, 4, figsize=(16, 4))
axes[0].hist(X, bins=30); axes[0].set_title('Original')
for ax, (name, sc) in zip(axes[1:], scalers.items()):
    ax.hist(sc.fit_transform(X), bins=30)
    ax.set_title(name)
plt.tight_layout()
plt.show()

त्वरित जाँच

इस पाठ के Python के साथ मशीन लर्निंग संबंधी अवधारणाओं की अपनी समझ जाँचें।

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

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

इस पाठ में आपने सीखा: दूरी-आधारित और ग्रेडिएंट-डिसेंट एल्गोरिदम के लिए विशेषता स्केलिंग क्यों आवश्यक है, StandardScaler किस तरह N(0,1) में मानकीकृत करता है जबकि MinMaxScaler मानों को [0,1] तक सीमित करता है, और leakage रोकने के लिए स्केलरों को केवल प्रशिक्षण डेटा पर फिट करने का महत्वपूर्ण नियम। अब हम OrdinalEncoder और OneHotEncoder से श्रेणीबद्ध चरों की एन्कोडिंग का अध्ययन करेंगे।

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

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

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

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

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

क्या “फ़ीचर स्केलिंग: StandardScaler और MinMaxScaler” पाठ निःशुल्क है?

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

“फ़ीचर स्केलिंग: StandardScaler और MinMaxScaler” में मैं क्या सीखूँगा?

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

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

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

“फ़ीचर स्केलिंग: StandardScaler और MinMaxScaler” पाठ पूरा करने में कितना समय लगता है?

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

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

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

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

  1. अनुपलब्ध मान सँभालना: हटाना, आरोपण और चिह्नित करना
  2. फ़ीचर स्केलिंग: StandardScaler और MinMaxScaler
  3. श्रेणीबद्ध चरों का एन्कोडिंग: OrdinalEncoder और OneHotEncoder
  4. ColumnTransformer से चरणों को जोड़ना
← Machine Learning Academy पर वापस जाएँ