|
|
# Scikit-learn का उपयोग करके रिग्रेशन मॉडल बनाएं: चार तरीकों से रिग्रेशन
|
|
|
|
|
|
## शुरुआत के लिए नोट
|
|
|
|
|
|
लाइनियर रिग्रेशन का उपयोग तब किया जाता है जब हम एक **संख्यात्मक मान** (उदाहरण के लिए, घर की कीमत, तापमान, या बिक्री) की भविष्यवाणी करना चाहते हैं।
|
|
|
यह इनपुट फीचर्स और आउटपुट के बीच संबंध को सबसे अच्छी तरह दर्शाने वाली एक सीधी रेखा खोजकर काम करता है।
|
|
|
|
|
|
इस पाठ में, हम अधिक उन्नत रिग्रेशन तकनीकों का पता लगाने से पहले अवधारणा को समझने पर ध्यान केंद्रित करते हैं।
|
|
|
|
|
|
> इनफोग्राफिक द्वारा [दसानी माडिपल्ली](https://twitter.com/dasani_decoded)
|
|
|
|
|
|
## [पूर्व-व्याख्यान प्रश्नोत्तरी](https://ff-quizzes.netlify.app/en/ml/)
|
|
|
|
|
|
> ### [यह पाठ R में भी उपलब्ध है!](../../../../2-Regression/3-Linear/solution/R/lesson_3.html)
|
|
|
|
|
|
### परिचय
|
|
|
|
|
|
अब तक आपने रिग्रेशन क्या है, इसे कद्दू की कीमतों के डेटासेट से प्राप्त नमूना डेटा के साथ समझा है, जिसे हम इस पाठ में उपयोग करेंगे। आपने इसे Matplotlib का उपयोग करके भी विज़ुअलाइज़ किया है।
|
|
|
|
|
|
अब आप एमएल के लिए रिग्रेशन में और गहराई तक जाने के लिए तैयार हैं। जबकि विज़ुअलाइज़ेशन आपको डेटा को समझने में मदद करता है, मशीन लर्निंग की असली ताकत _मॉडल ट्रेनिंग_ से आती है। मॉडल ऐतिहासिक डेटा पर प्रशिक्षित किए जाते हैं ताकि वे डेटा निर्भरताओं को स्वचालित रूप से पकड़ सकें, और नए डेटा के लिए पूर्वानुमान लगाने की अनुमति देते हैं, जिसे मॉडल ने पहले नहीं देखा होता है।
|
|
|
|
|
|
इस पाठ में, आप दो प्रकार के रिग्रेशन के बारे में और जानेंगे: _मूलभूत लाइनियर रिग्रेशन_ और _पॉलीनॉमियल रिग्रेशन_, साथ ही इन तकनीकों के पीछे की कुछ गणित। ये मॉडल हमें विभिन्न इनपुट डेटा के आधार पर कद्दू के दामों की भविष्यवाणी करने में सक्षम बनाएंगे।
|
|
|
|
|
|
[](https://youtu.be/CRxFT8oTDMg "एमएल शुरुआती के लिए - लाइनियर रिग्रेशन को समझना")
|
|
|
|
|
|
> 🎥 ऊपर दिए गए चित्र पर क्लिक करें लाइनियर रिग्रेशन का संक्षिप्त वीडियो अवलोकन देखने के लिए।
|
|
|
|
|
|
> इस पूरे पाठ्यक्रम में, हम गणित का न्यूनतम ज्ञान मानते हैं, और इसे उन छात्रों के लिए सुलभ बनाने का प्रयास करते हैं जो अन्य क्षेत्रों से आते हैं, इसलिए समझ में मदद के लिए नोट्स, 🧮 कॉलआउट्स, आरेख, और अन्य शिक्षण उपकरण देखें।
|
|
|
|
|
|
### पूर्वापेक्षा
|
|
|
|
|
|
अब तक आपको उस कद्दू डेटा की संरचना का परिचय मिल चुका होगा जिसका हम निरीक्षण कर रहे हैं। आप इसे इस पाठ के _notebook.ipynb_ फ़ाइल में पहले से लोड और साफ-सुथरा पा सकते हैं। फ़ाइल में, कद्दू की कीमत प्रति बशेल नए डेटा फ्रेम में दिखाई गई है। सुनिश्चित करें कि आप इन नोटबुक्स को Visual Studio Code में कर्नल में चला सकते हैं।
|
|
|
|
|
|
### तैयारी
|
|
|
|
|
|
एक अनुस्मारक के रूप में, आप यह डेटा इस उद्देश्य से लोड कर रहे हैं कि आप इसके बारे में प्रश्न पूछ सकें।
|
|
|
|
|
|
- कद्दू खरीदने का सबसे अच्छा समय कब होता है?
|
|
|
- मुझे मिनिएचर कद्दू के एक केस की क्या कीमत मिल सकती है?
|
|
|
- क्या मुझे उन्हें आधा-बशेल बास्केट में खरीदना चाहिए या 1 1/9 बशेल बॉक्स में?
|
|
|
|
|
|
आइए इस डेटा में और गहराई से उतारते रहें।
|
|
|
|
|
|
पिछले पाठ में, आपने एक Pandas डेटा फ्रेम बनाया और इसे मूल डेटासेट के एक हिस्से से भरा, प्राइजिंग को बशेल के अनुसार मानकीकृत करते हुए। ऐसा करते हुए, आप केवल लगभग 400 डेटा पॉइंट्स जुटा सके और वे केवल पतझड़ के महीनों के लिए थे।
|
|
|
|
|
|
इस पाठ के साथ आने वाली नोटबुक में प्रीलोड किए गए डेटा को देखें। डेटा पहले से लोड है और एक प्रारंभिक स्कैटरप्लॉट माह डेटा दिखाने के लिए बनाया गया है। शायद हम इसे और साफ़ करके डेटा की प्रकृति के बारे में थोड़ी अधिक जानकारी प्राप्त कर सकते हैं।
|
|
|
|
|
|
## एक लाइनियर रिग्रेशन लाइन
|
|
|
|
|
|
जैसा कि आपने पाठ 1 में सीखा, लाइनियर रिग्रेशन अभ्यास का उद्देश्य एक ऐसी रेखा प्लॉट करना है जो:
|
|
|
|
|
|
- **चर संबंध दर्शाए।** चर के बीच संबंध दिखाना
|
|
|
- **पूर्वानुमान करना।** यह सावधानीपूर्वक पूर्वानुमान लगाना कि नया डेटा पॉइंट उस रेखा के संबंध में कहां पड़ता है।
|
|
|
|
|
|
**लीस्ट-स्क्वेयर रिग्रेशन** के तहत ऐसी रेखा खींचना आम बात है। "लीस्ट-स्क्वेयर" शब्द हमारे मॉडल में कुल त्रुटि को न्यूनतम करने की प्रक्रिया को संदर्भित करता है। प्रत्येक डेटा पॉइंट के लिए, हम वास्तविक पॉइंट और हमारी रिग्रेशन रेखा के बीच ऊर्ध्वाधर दूरी (जिसे अवशिष्ट कहा जाता है) को मापते हैं।
|
|
|
|
|
|
हम इन दूरियों के वर्ग करते हैं इसके दो मुख्य कारण हैं:
|
|
|
|
|
|
1. **परिमाण अधिक महत्वपूर्ण है, दिशा नहीं:** हम -5 की त्रुटि को +5 की त्रुटि के समान मानना चाहते हैं। वर्ग करने से सभी मान सकारात्मक हो जाते हैं।
|
|
|
|
|
|
2. **बहिर्विष्टों को दंडित करना:** वर्ग करने से बड़ी त्रुटियों को अधिक महत्व मिलता है, जो रेखा को दूर के पॉइंट्स के करीब रहने के लिए बाध्य करता है।
|
|
|
|
|
|
फिर हम इन वर्गीकृत मानों को जोड़ते हैं। हमारा लक्ष्य वह विशिष्ट रेखा खोजने का है जहाँ यह अंतिम योग न्यूनतम हो (सबसे कम संभव मान) यही कारण है इसे "लीस्ट-स्क्वेयर" कहा जाता है।
|
|
|
|
|
|
> **🧮 मुझे गणित दिखाएं**
|
|
|
>
|
|
|
> इस रेखा, जिसे _सबसे उपयुक्त फिट रेखा_ कहा जाता है, को एक [समीकरण](https://en.wikipedia.org/wiki/Simple_linear_regression) द्वारा व्यक्त किया जा सकता है:
|
|
|
>
|
|
|
> ```
|
|
|
> Y = a + bX
|
|
|
> ```
|
|
|
>
|
|
|
> `X` 'व्याख्यात्मक चर' है। `Y` 'आश्रित चर' है। रेखा की ढलान `b` है और `a` y-अवरोध है, जो उस स्थिति को संदर्भित करता है जब `X = 0` होता है।
|
|
|
>
|
|
|
>
|
|
|
>
|
|
|
> सबसे पहले, ढलान `b` की गणना करें। इनफोग्राफिक द्वारा [जेन लूपर](https://twitter.com/jenlooper)
|
|
|
>
|
|
|
> दूसरे शब्दों में, और हमारे कद्दू डेटा के मूल प्रश्न को संदर्भित करते हुए: "माह के द्वारा प्रति बशेल कद्दू की कीमत की भविष्यवाणी करें", `X` मूल्य को संदर्भित करता है और `Y` बिक्री के माह को।
|
|
|
>
|
|
|
>
|
|
|
>
|
|
|
> Y का मान गणना करें। यदि आप लगभग $4 दे रहे हैं, तो यह अप्रैल होना चाहिए! इनफोग्राफिक द्वारा [जेन लूपर](https://twitter.com/jenlooper)
|
|
|
>
|
|
|
> गणित जो रेखा की गणना करता है वह रेखा की ढलान को दिखाना चाहिए, जो अवरोध पर भी निर्भर करता है, या जहां `Y` स्थित होता है जब `X = 0`
|
|
|
>
|
|
|
> आप इन मानों की गणना का तरीका [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html) वेबसाइट पर देख सकते हैं। साथ ही [यह लीस्ट-स्क्वेयर कैलकुलेटर](https://www.mathsisfun.com/data/least-squares-calculator.html) देखें कि संख्या के मान कैसे रेखा को प्रभावित करते हैं।
|
|
|
|
|
|
## सहसंबंध
|
|
|
|
|
|
एक और शब्द जिसे समझना जरूरी है वह है दी गई `X` और `Y` चर के बीच **सहसंबंध गुणांक**। स्कैटरप्लॉट का उपयोग करके, आप जल्दी से इस सहसंबंध को विज़ुअलाइज़ कर सकते हैं। एक प्लॉट जिसमें डेटा पॉइंट्स एक साफ रेखा में बिखरे हुए हों, उसका सहसंबंध उच्च होगा, जबकि एक प्लॉट जिसमें डेटा पॉइंट्स कहीं भी बिखरे हों, उसका सहसंबंध कम होगा।
|
|
|
|
|
|
एक अच्छा लाइनियर रिग्रेशन मॉडल वह होगा जिसमें लीस्ट-स्क्वेयर रिग्रेशन विधि के साथ रिग्रेशन लाइन वाले उच्च (0 से अधिक निकट 1) सहसंबंध गुणांक हो।
|
|
|
|
|
|
✅ इस पाठ के साथ आने वाली नोटबुक चलाएं और महीने के अनुसार कीमत के स्कैटरप्लॉट को देखें। क्या कद्दू बिक्री के लिए महीने और कीमत के बीच डेटा का सहसंबंध आपके विज़ुअल व्याख्या के अनुसार उच्च या निम्न लगता है? क्या यह तब बदलता है यदि आप `Month` के बजाय अधिक सूक्ष्म माप जैसे *साल का दिन* (उदाहरण के लिए वर्ष की शुरुआत से दिन की संख्या) का उपयोग करें?
|
|
|
|
|
|
नीचे दिए गए कोड में, हम मान लेते हैं कि हमने डेटा को साफ कर लिया है, और हमें एक डेटा फ्रेम `new_pumpkins` मिला है, जो निम्न जैसा है:
|
|
|
|
|
|
ID | Month | DayOfYear | Variety | City | Package | Low Price | High Price | Price
|
|
|
---|-------|-----------|---------|------|---------|-----------|------------|-------
|
|
|
70 | 9 | 267 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 15.0 | 15.0 | 13.636364
|
|
|
71 | 9 | 267 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 18.0 | 18.0 | 16.363636
|
|
|
72 | 10 | 274 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 18.0 | 18.0 | 16.363636
|
|
|
73 | 10 | 274 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 17.0 | 17.0 | 15.454545
|
|
|
74 | 10 | 281 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 15.0 | 15.0 | 13.636364
|
|
|
|
|
|
> डेटा साफ़ करने के लिए कोड [`notebook.ipynb`](notebook.ipynb) में उपलब्ध है। हमने पिछले पाठ की तरह ही सफाई के चरण किए हैं, और `DayOfYear` कॉलम को निम्न अभिव्यक्ति का उपयोग करके निकाला है:
|
|
|
|
|
|
```python
|
|
|
day_of_year = pd.to_datetime(pumpkins['Date']).apply(lambda dt: (dt-datetime(dt.year,1,1)).days)
|
|
|
```
|
|
|
|
|
|
अब जब आपको लाइनियर रिग्रेशन के पीछे गणित की समझ है, तो चलिए एक रिग्रेशन मॉडल बनाते हैं ताकि हम देख सकें कि कौन-सा कद्दू पैकेज सबसे अच्छे दाम देगा। कोई जो छुट्टियों के लिए कद्दू की खेती कर रहा है, वे इस जानकारी का उपयोग पैच के लिए अपने कद्दू पैकेजों की खरीद को अनुकूलित करने के लिए करना चाहेंगे।
|
|
|
|
|
|
## सहसंबंध की तलाश
|
|
|
|
|
|
[](https://youtu.be/uoRq-lW2eQo "एमएल शुरुआती के लिए - सहसंबंध की तलाश: लाइनियर रिग्रेशन की कुंजी")
|
|
|
|
|
|
> 🎥 ऊपर दिए गए चित्र पर क्लिक करें सहसंबंध का संक्षिप्त वीडियो अवलोकन देखने के लिए।
|
|
|
|
|
|
पिछले पाठ से आपने शायद देखा होगा कि विभिन्न महीनों के लिए औसत कीमत इस प्रकार है:
|
|
|
|
|
|
<img alt="Average price by month" src="../../../../translated_images/hi/barchart.a833ea9194346d76.webp" width="50%"/>
|
|
|
|
|
|
यह सुझाव देता है कि कुछ सहसंबंध होना चाहिए, और हम `Month` और `Price`, या `DayOfYear` और `Price` के बीच संबंध का पूर्वानुमान लगाने के लिए लाइनियर रिग्रेशन मॉडल प्रशिक्षण देने का प्रयास कर सकते हैं। यहाँ वह स्कैटरप्लॉट है जो बाद वाले संबंध को दिखाता है:
|
|
|
|
|
|
<img alt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/hi/scatter-dayofyear.bc171c189c9fd553.webp" width="50%" />
|
|
|
|
|
|
आइए देखें कि `corr` फ़ंक्शन का उपयोग करके सहसंबंध क्या है:
|
|
|
|
|
|
```python
|
|
|
print(new_pumpkins['Month'].corr(new_pumpkins['Price']))
|
|
|
print(new_pumpkins['DayOfYear'].corr(new_pumpkins['Price']))
|
|
|
```
|
|
|
|
|
|
ऐसा लगता है कि सहसंबंध काफी छोटा है, `Month` के लिए -0.15 और `DayOfMonth` के लिए -0.17, लेकिन एक और महत्वपूर्ण संबंध हो सकता है। ऐसा लगता है कि विभिन्न कद्दू किस्मों के लिए अलग-अलग क्लस्टर वाले दाम हैं। इस परिकल्पना की पुष्टि करने के लिए, चलिए हम प्रत्येक कद्दू श्रेणी को अलग रंग में प्लॉट करें। `scatter` प्लॉटिंग फ़ंक्शन में `ax` पैरामीटर पास करके हम सभी पॉइंट्स को एक ही ग्राफ़ पर प्लॉट कर सकते हैं।
|
|
|
|
|
|
```python
|
|
|
ax=None
|
|
|
colors = ['red','blue','green','yellow']
|
|
|
for i,var in enumerate(new_pumpkins['Variety'].unique()):
|
|
|
df = new_pumpkins[new_pumpkins['Variety']==var]
|
|
|
ax = df.plot.scatter('DayOfYear','Price',ax=ax,c=colors[i],label=var)
|
|
|
```
|
|
|
|
|
|
<img alt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/hi/scatter-dayofyear-color.65790faefbb9d54f.webp" width="50%" />
|
|
|
|
|
|
हमारे निरीक्षण से पता चलता है कि किस्म का दाम पर माह की तुलना में अधिक प्रभाव पड़ता है। हम इसे एक बार ग्राफ से देख सकते हैं:
|
|
|
|
|
|
```python
|
|
|
new_pumpkins.groupby('Variety')['Price'].mean().plot(kind='bar')
|
|
|
```
|
|
|
|
|
|
<img alt="Bar graph of price vs variety" src="../../../../translated_images/hi/price-by-variety.744a2f9925d9bcb4.webp" width="50%" />
|
|
|
|
|
|
आइए अभी केवल एक कद्दू किस्म, 'पाई टाइप' पर ध्यान केंद्रित करें, और देखें कि तारीख का कीमत पर क्या प्रभाव पड़ता है:
|
|
|
|
|
|
```python
|
|
|
pie_pumpkins = new_pumpkins[new_pumpkins['Variety']=='PIE TYPE']
|
|
|
pie_pumpkins.plot.scatter('DayOfYear','Price')
|
|
|
```
|
|
|
<img alt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/hi/pie-pumpkins-scatter.d14f9804a53f927e.webp" width="50%" />
|
|
|
|
|
|
यदि अब हम `Price` और `DayOfYear` के बीच सहसंबंध `corr` फ़ंक्शन का उपयोग कर गणना करें, तो हमें कुछ ऐसा मिलेगा: `-0.27` - जो दर्शाता है कि एक भविष्यवाणीक मॉडल प्रशिक्षण देना उचित है।
|
|
|
|
|
|
> लाइनियर रिग्रेशन मॉडल को प्रशिक्षित करने से पहले, यह सुनिश्चित करना महत्वपूर्ण है कि हमारा डेटा स्वच्छ हो। लाइनियर रिग्रेशन गायब मानों के साथ ठीक से काम नहीं करता, इसलिए सभी खाली सेल्स को हटाना समझदारी है:
|
|
|
|
|
|
```python
|
|
|
pie_pumpkins.dropna(inplace=True)
|
|
|
pie_pumpkins.info()
|
|
|
```
|
|
|
|
|
|
एक अन्य तरीका यह होगा कि ख़ाली मानों को संबंधित कॉलम के औसत मान से भर दें।
|
|
|
|
|
|
## सरल लाइनियर रिग्रेशन
|
|
|
|
|
|
[](https://youtu.be/e4c_UP2fSjg "एमएल शुरुआती के लिए - Scikit-learn का उपयोग करके लाइनियर और पॉलीनॉमियल रिग्रेशन")
|
|
|
|
|
|
> 🎥 ऊपर दिए गए चित्र पर क्लिक करें लाइनियर और पॉलीनॉमियल रिग्रेशन का संक्षिप्त वीडियो अवलोकन देखने के लिए।
|
|
|
|
|
|
हमारा लाइनियर रिग्रेशन मॉडल ट्रेनिंग के लिए, हम **Scikit-learn** लाइब्रेरी का उपयोग करेंगे।
|
|
|
|
|
|
```python
|
|
|
from sklearn.linear_model import LinearRegression
|
|
|
from sklearn.metrics import mean_squared_error
|
|
|
from sklearn.model_selection import train_test_split
|
|
|
```
|
|
|
|
|
|
हम प्रारंभ करते हैं इनपुट मानों (फीचर्स) और अपेक्षित आउटपुट (लेबल) को अलग-अलग numpy arrays में विभाजित करके:
|
|
|
|
|
|
```python
|
|
|
X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1)
|
|
|
y = pie_pumpkins['Price']
|
|
|
```
|
|
|
|
|
|
> ध्यान दें कि हमें इनपुट डेटा पर `reshape` करना पड़ा ताकि लाइनियर रिग्रेशन पैकेज इसे सही ढंग से समझ सके। लाइनियर रिग्रेशन 2D-array इनपुट की अपेक्षा करता है, जहाँ array की प्रत्येक पंक्ति इनपुट फीचर्स के वेक्टर को संदर्भित करती है। हमारे मामले में, क्योंकि हमारे पास केवल एक इनपुट है - हमें N×1 आकार की array चाहिए, जहाँ N डेटा सेट का आकार है।
|
|
|
|
|
|
फिर, हमें डेटा को प्रशिक्षु और परीक्षण डेटासेट में विभाजित करना होगा, ताकि ट्रेनिंग के बाद हम अपने मॉडल का मूल्यांकन कर सकें:
|
|
|
|
|
|
```python
|
|
|
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
|
|
|
```
|
|
|
|
|
|
अंत में, वास्तविक लाइनियर रिग्रेशन मॉडल को प्रशिक्षित करना केवल दो लाइन कोड लेता है। हम `LinearRegression` ऑब्जेक्ट को परिभाषित करते हैं, और इसे `fit` विधि का उपयोग करके हमारे डेटा पर फिट करते हैं:
|
|
|
|
|
|
```python
|
|
|
lin_reg = LinearRegression()
|
|
|
lin_reg.fit(X_train,y_train)
|
|
|
```
|
|
|
|
|
|
`LinearRegression` ऑब्जेक्ट `fit` करने के बाद रिग्रेशन के सभी गुणांक (coefficients) रखता है, जिन्हें `.coef_` प्रॉपर्टी का उपयोग करके एक्सेस किया जा सकता है। हमारे मामले में, केवल एक गुणांक है, जो लगभग `-0.017` के आसपास होना चाहिए। इसका मतलब है कि कीमतें समय के साथ थोड़ा गिरती हैं, लेकिन अधिक नहीं, लगभग 2 सेंट प्रति दिन। हम रिग्रेशन के Y-अक्ष के साथ कटाव (intersection point) को भी `lin_reg.intercept_` का उपयोग करके एक्सेस कर सकते हैं - हमारे मामले में यह लगभग `21` के आसपास होगा, जो वर्ष की शुरुआत में कीमत को दर्शाता है।
|
|
|
|
|
|
देखने के लिए कि हमारा मॉडल कितना सटीक है, हम टेस्ट डेटासेट पर कीमतों की भविष्यवाणी कर सकते हैं, और फिर माप सकते हैं कि हमारी भविष्यवाणियां अपेक्षित मूल्यों के कितनी निकट हैं। इसे मीन स्क्वायर एरर (MSE) मेट्रिक्स का उपयोग करके किया जा सकता है, जो अपेक्षित और पूर्वानुमानित मूल्य के बीच सभी स्क्वायर्ड अंतर का औसत है।
|
|
|
|
|
|
```python
|
|
|
pred = lin_reg.predict(X_test)
|
|
|
|
|
|
mse = np.sqrt(mean_squared_error(y_test,pred))
|
|
|
print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)')
|
|
|
```
|
|
|
|
|
|
हमारी त्रुटि लगभग 2 पॉइंट्स के आसपास लगती है, जो ~17% है। बहुत अच्छी नहीं। मॉडल की गुणवत्ता का एक अन्य संकेतक है **निर्धारण गुणांक** (coefficient of determination), जिसे इस प्रकार प्राप्त किया जा सकता है:
|
|
|
|
|
|
```python
|
|
|
score = lin_reg.score(X_train,y_train)
|
|
|
print('Model determination: ', score)
|
|
|
```
|
|
|
यदि मान 0 है, तो इसका मतलब है कि मॉडल इनपुट डेटा को ध्यान में नहीं रखता है, और *सबसे खराब रैखिक पूर्वानुमानक* के रूप में कार्य करता है, जो परिणाम का केवल औसत मान है। मान 1 का मतलब है कि हम सभी अपेक्षित आउटपुट्स को पूरी तरह से सही पूर्वानुमानित कर सकते हैं। हमारे मामले में, गुणांक लगभग 0.06 के आसपास है, जो काफी कम है।
|
|
|
|
|
|
हम परीक्षण डेटा को रिग्रेशन लाइन के साथ भी प्लॉट कर सकते हैं ताकि बेहतर तरीके से देख सकें कि हमारे मामले में रिग्रेशन कैसे काम करता है:
|
|
|
|
|
|
```python
|
|
|
plt.scatter(X_test,y_test)
|
|
|
plt.plot(X_test,pred)
|
|
|
```
|
|
|
|
|
|
<img alt="Linear regression" src="../../../../translated_images/hi/linear-results.f7c3552c85b0ed1c.webp" width="50%" />
|
|
|
|
|
|
## बहुपद रिग्रेशन (Polynomial Regression)
|
|
|
|
|
|
रैखिक रिग्रेशन का एक अन्य प्रकार है बहुपद रिग्रेशन। जबकि कभी-कभी चर के बीच रैखिक संबंध होता है - जैसे लंबे आकार वाला कद्दू का दाम अधिक होता है - कभी-कभी इन संबंधों को तल या सीधी रेखा के रूप में प्रदर्शित नहीं किया जा सकता।
|
|
|
|
|
|
✅ यहां [कुछ और उदाहरण](https://online.stat.psu.edu/stat501/lesson/9/9.8) हैं जिनमें बहुपद रिग्रेशन का उपयोग किया जा सकता है
|
|
|
|
|
|
दिनांक और मूल्य के संबंध को फिर से देखें। क्या यह स्कैटरप्लॉट इस तरह दिखता है कि इसे ज़रूरी तौर पर सीधी रेखा से विश्लेषित किया जाना चाहिए? क्या कीमतें स्थिर नहीं रह सकतीं? इस मामले में, आप बहुपद रिग्रेशन आजमा सकते हैं।
|
|
|
|
|
|
✅ बहुपद गणितीय व्यंजक होते हैं जो एक या अधिक चर और गुणांकों से मिलकर बनते हैं
|
|
|
|
|
|
बहुपद रिग्रेशन एक वक्र रेखा बनाता है जिससे गैर-रैखिक डेटा में बेहतर फिटिंग हो सके। हमारे मामले में, यदि हम इनपुट डेटा में स्क्वायर्ड `DayOfYear` वेरिएबल शामिल करें, तो हम डेटा को एक परवलयाकार वक्र से फिट कर पाएंगे, जिसका न्यूनतम वर्ष के किसी निश्चित बिंदु पर होगा।
|
|
|
|
|
|
Scikit-learn में एक उपयोगी [pipeline API](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) शामिल है जो डेटा प्रोसेसिंग के विभिन्न चरणों को एक साथ जोड़ता है। एक **पाइपलाइन** **एस्टिमेटर्स** की एक श्रृंखला होती है। हमारे मामले में, हम एक पाइपलाइन बनाएंगे जो पहले हमारे मॉडल में बहुपद विशेषताओं को जोड़ता है, और फिर रिग्रेशन को प्रशिक्षित करता है:
|
|
|
|
|
|
```python
|
|
|
from sklearn.preprocessing import PolynomialFeatures
|
|
|
from sklearn.pipeline import make_pipeline
|
|
|
|
|
|
pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
|
|
|
|
|
|
pipeline.fit(X_train,y_train)
|
|
|
```
|
|
|
|
|
|
`PolynomialFeatures(2)` का उपयोग करने का मतलब है कि हम इनपुट डेटा से सभी द्वितीय-डिग्री बहुपद शामिल करेंगे। हमारे मामले में इसका मतलब केवल `DayOfYear`<sup>2</sup> होगा, लेकिन यदि दो इनपुट वेरिएबल X और Y हों, तो यह X<sup>2</sup>, XY और Y<sup>2</sup> जोड़ता है। हम उच्च-डिग्री बहुपद भी उपयोग कर सकते हैं यदि चाहें।
|
|
|
|
|
|
पाइपलाइनों का उपयोग उसी तरह किया जा सकता है जैसे `LinearRegression` ऑब्जेक्ट का, यानी हम पाइपलाइन को `fit` कर सकते हैं, और फिर भविष्यवाणी परिणामों के लिए `predict` का उपयोग कर सकते हैं। यहां ग्राफ है जो परीक्षण डेटा और अनुमानित वक्र को दिखाता है:
|
|
|
|
|
|
<img alt="Polynomial regression" src="../../../../translated_images/hi/poly-results.ee587348f0f1f60b.webp" width="50%" />
|
|
|
|
|
|
बहुपद रिग्रेशन का उपयोग करते हुए, हम थोड़ा कम MSE और उच्च निर्धारण प्राप्त कर सकते हैं, लेकिन विशेष रूप से नहीं। हमें अन्य विशेषताओं को भी ध्यान में रखना होगा!
|
|
|
|
|
|
> आप देख सकते हैं कि न्यूनतम कद्दू के दाम लगभग हैलोवीन के आसपास होते हैं। आप इसे कैसे समझाएंगे?
|
|
|
|
|
|
🎃 बधाई हो, आपने एक ऐसा मॉडल बनाया है जो पाई कद्दू की कीमत का पूर्वानुमान लगाने में मदद कर सकता है। आप संभवतः सभी कद्दू प्रकारों के लिए समान प्रक्रिया दोहरा सकते हैं, लेकिन वह थकाऊ होगा। अब सीखते हैं कि हमारे मॉडल में कद्दू की किस्म को कैसे ध्यान में रखा जाए!
|
|
|
|
|
|
## श्रेणीबद्ध विशेषताएँ (Categorical Features)
|
|
|
|
|
|
आदर्श दुनिया में, हम एक ही मॉडल का उपयोग करके विभिन्न कद्दू किस्मों के लिए कीमतों की भविष्यवाणी कर सके। हालांकि, `Variety` कॉलम कुछ हद तक `Month` जैसे कॉलमों से अलग है, क्योंकि इसमें गैर-आंकिक (non-numeric) मान होते हैं। ऐसे कॉलम को **श्रेणीबद्ध** कहा जाता है।
|
|
|
|
|
|
[](https://youtu.be/DYGliioIAE0 "ML for beginners - Categorical Feature Predictions with Linear Regression")
|
|
|
|
|
|
> 🎥 श्रेणीबद्ध विशेषताओं के उपयोग पर एक संक्षिप्त वीडियो अवलोकन के लिए ऊपर की छवि पर क्लिक करें।
|
|
|
|
|
|
यहाँ आप देख सकते हैं कि औसत कीमत किस्म पर कैसे निर्भर करती है:
|
|
|
|
|
|
<img alt="Average price by variety" src="../../../../translated_images/hi/price-by-variety.744a2f9925d9bcb4.webp" width="50%" />
|
|
|
|
|
|
किस्म को ध्यान में रखने के लिए, हमें पहले इसे संख्यात्मक रूप में कनवर्ट या **एन्कोड** करना होगा। इसे करने के कई तरीके हैं:
|
|
|
|
|
|
* सरल **न्यूमेरिक एन्कोडिंग** एक अलग किस्मों की तालिका बनाएगा, और फिर किस्म के नाम को उस तालिका में इंडेक्स द्वारा प्रतिस्थापित करेगा। यह रैखिक रिग्रेशन के लिए अच्छा विचार नहीं है, क्योंकि रैखिक रिग्रेशन इंडेक्स का वास्तविक संख्यात्मक मान लेता है, और इसे गुणांक से गुणा करके परिणाम में जोड़ता है। हमारे मामले में, इंडेक्स संख्या और कीमत के बीच संबंध स्पष्ट रूप से गैर-रैखिक है, भले ही हम सुनिश्चत कर लें कि इंडेक्सों को किसी विशिष्ट क्रम में व्यवस्थित किया गया हो।
|
|
|
* **वन-हॉट एन्कोडिंग** `Variety` कॉलम को चार अलग-अलग कॉलमों में बदल देगा, प्रत्येक किस्म के लिए एक। प्रत्येक कॉलम में `1` होगा यदि संबंधित पंक्ति उस विशिष्ट किस्म की हो, अन्यथा `0` होगा। इसका मतलब है कि रैखिक रिग्रेशन में चार गुणांक होंगे, प्रत्येक कद्दू किस्म के लिए, जो उस विशेष किस्म की "शुरुआती कीमत" (या अधिक सटीक कहा जाए तो "अतिरिक्त कीमत") के लिए जिम्मेदार होगा।
|
|
|
|
|
|
नीचे का कोड दिखाता है कि हम किस प्रकार एक किस्म को वन-हॉट एन्कोड कर सकते हैं:
|
|
|
|
|
|
```python
|
|
|
pd.get_dummies(new_pumpkins['Variety'])
|
|
|
```
|
|
|
|
|
|
ID | FAIRYTALE | MINIATURE | MIXED HEIRLOOM VARIETIES | PIE TYPE
|
|
|
----|-----------|-----------|--------------------------|----------
|
|
|
70 | 0 | 0 | 0 | 1
|
|
|
71 | 0 | 0 | 0 | 1
|
|
|
... | ... | ... | ... | ...
|
|
|
1738 | 0 | 1 | 0 | 0
|
|
|
1739 | 0 | 1 | 0 | 0
|
|
|
1740 | 0 | 1 | 0 | 0
|
|
|
1741 | 0 | 1 | 0 | 0
|
|
|
1742 | 0 | 1 | 0 | 0
|
|
|
|
|
|
वन-हॉट एन्कोडेड किस्म को इनपुट के रूप में उपयोग करके रैखिक रिग्रेशन को प्रशिक्षित करने के लिए, हमें केवल `X` और `y` डेटा को सही ढंग से इनिशियलाइज़ करना होगा:
|
|
|
|
|
|
```python
|
|
|
X = pd.get_dummies(new_pumpkins['Variety'])
|
|
|
y = new_pumpkins['Price']
|
|
|
```
|
|
|
|
|
|
बाकी कोड वही है जो हमने ऊपर रैखिक रिग्रेशन प्रशिक्षित करने के लिए इस्तेमाल किया था। यदि आप इसे आज़माते हैं, तो आप देखेंगे कि मीन स्क्वायर एरर लगभग समान है, लेकिन हमें निर्धारण गुणांक (~77%) बहुत अधिक मिलता है। और अधिक सटीक भविष्यवाणियां पाने के लिए, हम अधिक श्रेणीबद्ध विशेषताओं के साथ-साथ संख्यात्मक विशेषताओं को भी ध्यान में ले सकते हैं, जैसे कि `Month` या `DayOfYear`। सभी फीचर्स का एक बड़ा ऐरे पाने के लिए, हम `join` का उपयोग कर सकते हैं:
|
|
|
|
|
|
```python
|
|
|
X = pd.get_dummies(new_pumpkins['Variety']) \
|
|
|
.join(new_pumpkins['Month']) \
|
|
|
.join(pd.get_dummies(new_pumpkins['City'])) \
|
|
|
.join(pd.get_dummies(new_pumpkins['Package']))
|
|
|
y = new_pumpkins['Price']
|
|
|
```
|
|
|
|
|
|
यहां हम `City` और `Package` प्रकार को भी ध्यान में लेते हैं, जो हमें MSE 2.84 (10%) और निर्धारण 0.94 देता है!
|
|
|
|
|
|
## सब कुछ एक साथ जोड़ना
|
|
|
|
|
|
सबसे अच्छा मॉडल बनाने के लिए, हम उपरोक्त उदाहरण से संयुक्त (वन-हॉट एन्कोडेड श्रेणीबद्ध + संख्यात्मक) डेटा को बहुपद रिग्रेशन के साथ उपयोग कर सकते हैं। आपके सुविधाजनक उपयोग के लिए यहां पूर्ण कोड है:
|
|
|
|
|
|
```python
|
|
|
# प्रशिक्षण डेटा सेट करें
|
|
|
X = pd.get_dummies(new_pumpkins['Variety']) \
|
|
|
.join(new_pumpkins['Month']) \
|
|
|
.join(pd.get_dummies(new_pumpkins['City'])) \
|
|
|
.join(pd.get_dummies(new_pumpkins['Package']))
|
|
|
y = new_pumpkins['Price']
|
|
|
|
|
|
# ट्रेन-टेस्ट विभाजन करें
|
|
|
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
|
|
|
|
|
|
# पाइपलाइन सेटअप करें और प्रशिक्षित करें
|
|
|
pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
|
|
|
pipeline.fit(X_train,y_train)
|
|
|
|
|
|
# परीक्षण डेटा के लिए परिणाम पूर्वानुमान करें
|
|
|
pred = pipeline.predict(X_test)
|
|
|
|
|
|
# MSE और निर्धारण की गणना करें
|
|
|
mse = np.sqrt(mean_squared_error(y_test,pred))
|
|
|
print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)')
|
|
|
|
|
|
score = pipeline.score(X_train,y_train)
|
|
|
print('Model determination: ', score)
|
|
|
```
|
|
|
|
|
|
यह हमें लगभग 97% का सर्वोत्तम निर्धारण गुणांक और MSE=2.23 (~8% पूर्वानुमान त्रुटि) देगा।
|
|
|
|
|
|
| मॉडल | MSE | निर्धारण |
|
|
|
|-------|-----|---------------|
|
|
|
| `DayOfYear` रैखिक | 2.77 (17.2%) | 0.07 |
|
|
|
| `DayOfYear` बहुपद | 2.73 (17.0%) | 0.08 |
|
|
|
| `Variety` रैखिक | 5.24 (19.7%) | 0.77 |
|
|
|
| सभी फीचर्स रैखिक | 2.84 (10.5%) | 0.94 |
|
|
|
| सभी फीचर्स बहुपद | 2.23 (8.25%) | 0.97 |
|
|
|
|
|
|
🏆 बहुत अच्छा! आपने एक पाठ में चार रिग्रेशन मॉडल बनाए, और मॉडल की गुणवत्ता को 97% तक बढ़ाया। रिग्रेशन के अंतिम भाग में, आप लॉजिस्टिक रिग्रेशन के बारे में सीखेंगे जिससे श्रेणियां निर्धारित की जा सकेंगी।
|
|
|
|
|
|
---
|
|
|
## 🚀चुनौती (Challenge)
|
|
|
|
|
|
इस नोटबुक में कई अलग-अलग चर परिक्षण करें ताकि देखें कि सहसंबंध मॉडल की सटीकता से कैसे संबंधित है।
|
|
|
|
|
|
## [पाठ के बाद क्विज़](https://ff-quizzes.netlify.app/en/ml/)
|
|
|
|
|
|
## पुनरावलोकन और स्व-अध्ययन
|
|
|
|
|
|
इस पाठ में हमने रैखिक रिग्रेशन के बारे में सीखा। अन्य महत्वपूर्ण प्रकार के रिग्रेशन भी हैं। स्टेपवाइज, रिज, लासो और इलास्टिकनेट तकनीकों के बारे में पढ़ें। अधिक जानने के लिए एक अच्छा कोर्स है [Stanford Statistical Learning course](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning)
|
|
|
|
|
|
## असाइनमेंट
|
|
|
|
|
|
[मॉडल बनाएँ](assignment.md)
|
|
|
|
|
|
---
|
|
|
|
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
|
|
|
**अस्वीकरण**:
|
|
|
इस दस्तावेज़ का अनुवाद AI अनुवाद सेवा [Co-op Translator](https://github.com/Azure/co-op-translator) का उपयोग करके किया गया है। यद्यपि हम सटीकता के लिए प्रयासरत हैं, कृपया ध्यान दें कि स्वचालित अनुवाद में त्रुटियां या गलतियां हो सकती हैं। मूल दस्तावेज़ अपनी मूल भाषा में अधिकृत स्रोत माना जाना चाहिए। महत्वपूर्ण जानकारी के लिए पेशेवर मानव अनुवाद की सिफारिश की जाती है। इस अनुवाद के उपयोग से उत्पन्न किसी भी गलतफहमी या गलत व्याख्या के लिए हम ज़िम्मेदार नहीं हैं।
|
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER END --> |
