मशीन लर्निंग के बुनियादी सिद्धांतमध्यमपाठ 1095 मिनट का पाठ

आपकी पहली प्रेडिक्शन: लीनियर रिग्रेशन (linear regression)

scikit-learn की मदद से डेटा पर एक सीधी रेखा (straight line) फिट करें, नंबर्स प्रेडिक्ट करने के लिए इसका इस्तेमाल करें, और एक आसान बेसलाइन से तुलना करें ताकि आपको पता चले कि क्या यह सच में मददगार है।

✦ ट्यूटर से पूछें🧪 लैब · 20 min📝 पाठ का टेस्ट
पाठ वीडियो में

60 सेकंड में

आपकी पहली प्रेडिक्शन: लीनियर रिग्रेशन (linear regression)

scikit-learn की मदद से डेटा पर एक सीधी रेखा (straight line) फिट करें, नंबर्स प्रेडिक्ट करने के लिए इसका इस्तेमाल करें, और एक आसान बेसलाइन से तुलना करें ताकि आपको पता चले कि क्या…

1/4
आसान शब्दों में
एक केटरर ध्यान देता है कि बड़ी शादियों में ज़्यादा चावल की ज़रूरत होती है। 100 मेहमानों के लिए उन्होंने लगभग इतना पकाया, 300 मेहमानों के लिए लगभग तीन गुना ज़्यादा। अगर आप इन्हें किसी ग्राफ़ पर बनाएं, तो ये पॉइंट्स मोटे तौर पर एक सीधी रेखा बनाते हैं। अगली बार, वे अंदाज़ा लगाने के लिए उस रेखा को देख सकते हैं कि कितना चावल पकाना है। वह रेखा एक लीनियर रिग्रेशन मॉडल है।
लीनियर रिग्रेशन एक सीधी-रेखा वाले नियम से किसी नंबर को प्रेडिक्ट करता है:
prediction = slope × feature + intercept
कई सारे फ़ीचर्स होने पर, हर फ़ीचर का अपना एक स्लोप होता है (जिसे coefficient कहते हैं), और सभी हिस्सों को जोड़ दिया जाता है। ट्रेनिंग ऐसे स्लोप और इंटरसेप्ट ढूंढती है जिससे ट्रेनिंग उदाहरणों पर squared एरर (त्रुटियां) कम से कम हो जाएं।

scikit-learn का तरीका (pattern)

हर scikit-learn मॉडल इन्हीं तीन स्टेप्स का पालन करता है। इन्हें एक बार सीख लें और आप दर्जनों मॉडल्स का इस्तेमाल कर सकते हैं।
  1. 1

    बनाएं (Create)

    model = LinearRegression()
  2. 2

    फ़िट करें (ट्रेन करें)

    model.fit(X_train, y_train) सबसे बेहतरीन स्लोप ढूंढता है।
  3. 3

    प्रेडिक्ट करें (Predict)

    model.predict(X_new) नई पंक्तियों (rows) के लिए नंबर्स देता है।
Python: made-up guests and ricepython
import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression

# Made-up data: wedding guests and kg of rice cooked. Not real figures.
rng = np.random.default_rng(1)
guests = rng.integers(50, 500, 25)
rice_kg = 0.15 * guests + 5 + rng.normal(0, 4, 25)

X = guests.reshape(-1, 1)          # scikit-learn wants a 2-D table
model = LinearRegression().fit(X, rice_kg)

print("Slope (kg per guest):", round(model.coef_[0], 3))
print("Intercept (kg):", round(model.intercept_, 2))
print("Prediction for 250 guests:", round(model.predict([[250]])[0], 1), "kg")

xs = np.array([[50], [500]])
plt.scatter(guests, rice_kg, label="made-up examples")
plt.plot(xs, model.predict(xs), color="red", label="learned line")
plt.xlabel("guests"); plt.ylabel("rice (kg)"); plt.legend()
सीखा हुआ स्लोप 0.15 के करीब आता है, यही वह नंबर है जिसका इस्तेमाल हमने डेटा बनाने के लिए किया था। यह एक अच्छा संकेत है: नॉइज़ (noise) होने के बावजूद, इस तरीके ने उस पैटर्न को खोज निकाला जो हमने इसमें छिपाया था।

एरर नापना

माप (Measure)इसका क्या मतलब हैनोट्स
MAE (मीन एब्सोल्यूट एरर)गलती का औसत साइज़लेबल वाली ही यूनिट; समझाना आसान है
RMSE (रूट मीन स्क्वेर्ड एरर)MAE की तरह ही है, लेकिन बड़ी गलतियों पर ज़्यादा पेनल्टी लगाता हैलेबल वाली ही यूनिट
R² (R-स्क्वेर्ड)मॉडल वेरिएशन के कितने हिस्से को समझा पाता है1 एकदम सटीक है, 0 का मतलब केवल औसत प्रेडिक्ट करने से बेहतर कुछ नहीं; नेगेटिव भी हो सकता है

हमेशा बेसलाइन से तुलना करें

एक बेसलाइन सबसे आसान मुमकिन प्रेडिक्शन होती है। रिग्रेशन के लिए, हर पंक्ति के लिए ट्रेनिंग लेबल्स का औसत (average) प्रेडिक्ट करें। अगर आपका मॉडल इसे भी मात नहीं दे सकता, तो उसने कुछ भी काम का नहीं सीखा है। अकेले "MAE = 20" जैसे नंबर का कोई मतलब नहीं होता; "22 की बेसलाइन के मुकाबले MAE 20" आपको बताता है कि मॉडल मदद तो करता है, लेकिन बस थोड़ी सी।
सावधान रहें
ऐसे डेटा पर टेस्ट करें जिस पर मॉडल ने ट्रेनिंग न ली हो। ट्रेनिंग वाली पंक्तियों पर एरर ज़रूरत से ज़्यादा अच्छी (optimistic) दिखती है। हम कुछ पंक्तियों को अलग रखने के लिए train_test_split का इस्तेमाल करते हैं। "ईमानदारी से काम करना" यूनिट में इसे और गहराई से समझाया गया है।

जब सीधी रेखा गलत आकार साबित हो

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

और देखें और पढ़ें

scikit-learn: Linear modelsscikit-learn · reading

लैब

एक फ़ीचर का इस्तेमाल करके डायबिटीज डेटासेट पर लीनियर रिग्रेशन, जिसे अलग रखे गए टेस्ट सेट पर स्कोर किया गया और बेसलाइन से तुलना की गई।

~20 min

समस्या

diabetes डेटासेट में 442 मरीज़ हैं, हर एक के 10 माप (पहले से स्केल्ड हैं, इसलिए वैल्यूज़ 0 के आसपास छोटे नंबर्स हैं), और एक नंबर जो मापता है कि एक साल बाद बीमारी कितनी आगे बढ़ी। यह सिर्फ़ सिखाने के लिए एक डेटासेट है, कोई मेडिकल सलाह नहीं।

  1. स्टार्टर कोड रन करें। यह फ़ीचर के रूप में केवल bmi कॉलम का इस्तेमाल करता है और डेटा को स्प्लिट करता है।
  2. model नाम से एक LinearRegression बनाएं और इसे केवल ट्रेनिंग पंक्तियों पर फ़िट करें।
  3. test_mae कैलकुलेट करें: टेस्ट पंक्तियों पर मॉडल का मीन एब्सोल्यूट एरर।
  4. baseline_mae कैलकुलेट करें: यदि आप हर टेस्ट पंक्ति के लिए ट्रेनिंग औसत प्रेडिक्ट करते हैं तो आने वाला टेस्ट एरर।
  5. दोनों को प्रिंट करें। क्या मॉडल बेसलाइन से बेहतर प्रदर्शन करता है? कितने अंतर से?

प्रैक्टिस लैब

कोड में बदलाव करें और इसे रन करें। Python आपके ब्राउज़र में चलता है — हमारे सर्वर पर कुछ नहीं भेजा जाता।

आउटपुट

कोई आउटपुट नहीं। वैल्यूज़ देखने के लिए print(...) जोड़ें।

आपका काम तब पूरा होगा जब

कठिन सवाल

उत्तर देखने से पहले ख़ुद जवाब देने की कोशिश करें। अगर आप इनके जवाब दे सकते हैं, तो आप पाठ समझ गए हैं।

Q1बेसलाइन को ट्रेनिंग औसत का ही इस्तेमाल क्यों करना चाहिए, टेस्ट औसत का क्यों नहीं?दिखाएं

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

Q2एक दूसरा फ़ीचर, <code>s5</code> जोड़ें, ताकि X में दो कॉलम हों। आप क्या उम्मीद करते हैं, और आप यह कैसे जांचेंगे कि यह सिर्फ़ किस्मत का खेल नहीं है?दिखाएं

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

जारी रखने के लिए कृपया साइन इन करें।

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

scikit-learn को सिर्फ़ एक फ़ीचर के लिए भी X 2-D टेबल के रूप में क्यों चाहिए होता है?

क्योंकि वही कोड एक फ़ीचर के लिए भी काम करना चाहिए और सौ फ़ीचर्स के लिए भी। X हमेशा पंक्तियां गुणा कॉलम (rows by columns) होता है। reshape(-1, 1) एक सपाट लिस्ट को एक कॉलम में बदल देता है, या आप एक कॉलम वाला DataFrame भी पास कर सकते हैं।

क्या बड़े स्लोप का मतलब है कि फ़ीचर महत्वपूर्ण है?

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

क्या लीनियर रिग्रेशन कारण और प्रभाव (cause and effect) को दिखाता है?

नहीं। यह डेटा में सिर्फ़ एक पैटर्न ढूंढता है। गर्मियों में आइसक्रीम की बिक्री और डूबने की घटनाएं दोनों साथ में बढ़ती हैं, लेकिन एक दूसरे का कारण नहीं है। कारणों को समझने के लिए सावधानीपूर्वक स्टडी डिज़ाइन की ज़रूरत होती है, सिर्फ़ एक फ़िट की गई रेखा की नहीं।

random_state क्या है?

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

पाठ का टेस्ट

5 सवाल। पास होने और इस पाठ को पूरा करने के लिए 3 सही होने चाहिए (60%)।

टेस्ट देने और अपनी प्रोग्रेस सेव करने के लिए साइन इन करें