|
|
# స్కికిట్-లెర్న్ ఉపయోగించి రిగ్రెషన్ మోడల్ అన్వయించండి: రిగ్రెషన్ నాలుగు మార్గాలు
|
|
|
|
|
|
## ప్రారంభిక గమనిక
|
|
|
|
|
|
లీనియర్ రిగ్రెషన్ ను మనం **సంఖ్యాత్మక విలువ** (ఉదాహరణకి, ఇల్లు ధర, ఉష్ణోగ్రత, లేదా అమ్మకాలు) అంచనా వేయాలనుకునేటప్పుడు ఉపయోగిస్తాము. ఇది ఇన్పుట్ లక్షణాలు మరియు ఔట్పుట్ మధ్య సంబంధాన్ని ఉత్తమంగా వివరించే ఒక సరళ రేఖను కనుగొనేంది.
|
|
|
|
|
|
ఈ పాఠంలో, మరింత ముందడుగు రిగ్రెషన్ సాంకేతికతలను అన్వేషించే ముందు కాన్సెప్టును అర్థం చేసుకోవడంపై మనం దృష్టి ఇస్తాము.
|
|
|
|
|
|
> ఇన్ఫోగ్రాఫిక్ అందించిన [దసాని మడిపల్లి](https://twitter.com/dasani_decoded) ద్వారా
|
|
|
## [పూర్వ-పాఠ్య క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
|
|
|
|
|
|
> ### [ఈ పాఠం R లో అందుబాటులో ఉంది!](../../../../2-Regression/3-Linear/solution/R/lesson_3.html)
|
|
|
### పరిచయం
|
|
|
|
|
|
ఇప్పటి వరకు మీరు రిగ్రెషన్ అంటే ఏమిటో, మరియు మనం ఈ పాఠంలో మొత్తం ఉపయోగించే పంక్పిన్ ధరల డేటా సెట్ నుండి సేకరించిన నమూనా డేటాతో ఎలా పరిశీలించారో తెలుసుకున్నారు. మీరు Matplotlib ఉపయోగించి దాన్ని విజువలైజ్ కూడా చేశారు.
|
|
|
|
|
|
ఇప్పుడు మీరు ML కోసం రిగ్రెషన్ లో మరింత లోతుగా దిగి చూడడానికి సిద్ధంగా ఉన్నారు. విజువలైజేషన్ డేటాను అర్థం చేసుకోవడానికి ఉపయోగపడినప్పటికీ, మెషిన్ లెర్నింగ్ యొక్క వాస్తవ శక్తి _మోడల్స్ శిక్షణ_ లోనిది. మోడల్స్ పాత డేటా పై శిక్షణ పొందుతాయి, డేటా సంబంధాలను ఆటోమేటిక్గా క్యాప్చర్ చేయడానికి, మరియు కొత్త డేటా కోసం ఫలితాలను అంచనా వేయడానికి వీలు కల్పిస్తాయి, మోడల్ ముందు చూడని డేటా కావు.
|
|
|
|
|
|
ఈ పాఠంలో, మీరు రెండు రకాల రిగ్రెషన్ల గురించి మెరుపు అవుతారు: _మూల లీనియర్ రిగ్రెషన్_ మరియు _పోలినోమియల్ రిగ్రెషన్_, వీటి పక్కన ఈ సాంకేతికతలకు మత్తమెరుగైన గణితంను తెలుసుకుంటారు. ఆ మోడల్స్ మనకు వేర్వేరు ఇన్పుట్ డేటాపై ఆధారపడి పంక్పిన్ ధరలను అంచనా వేయడానికి అనుమతిస్తాయి.
|
|
|
|
|
|
[](https://youtu.be/CRxFT8oTDMg "ML for beginners - Understanding Linear Regression")
|
|
|
|
|
|
> 🎥 లీనియర్ రిగ్రెషన్ యొక్క చిన్న వీడియో ఓవర్వ్యూ కోసం పై చిత్రాన్నిపై క్లిక్ చేయండి.
|
|
|
|
|
|
> ఈ సిలబస్ అంతటా, మనం గణితంలో కనీస పరిమిత జ్ఞానం కలిగి ఉన్నవారిగా భావించి, ఇతర రంగాల నుండే వచ్చే విద్యార్థులకు సులభంగా అర్థం అవ్వాలనే ఉద్దేశంతో, గమనికలు, 🧮 సూచనలు, చిత్రలేఖనాలు మరియు ఇతర శిక్షణా పరికరాలతో సహాయపడుతాము.
|
|
|
|
|
|
### ముందస్తు అవగాహన
|
|
|
|
|
|
మీరు ఇప్పటివరకు పరిశీలిస్తున్న పంక్పిన్ డేటా నిర్మాణాన్ని బాగా తెలుసుకుని ఉండాలి. ఈ పాఠంలోని _notebook.ipynb_ ఫైల్లో అది ముందే లోడ్ చేసి శుభ్రపరిచిన రూపంలో ఉంటుంది. ఆ ఫైలులో, పంక్పిన్ ధర కొత్త డేటా ఫ్రేమ్లో బయటపడ్డాయి, బషెల్కు సంబంధించి. మీరు Visual Studio Code లో కర్నల్స్ లో ఈ నోట్బుక్స్ ను అమలు చేయగలదని నిర్ధారించుకోండి.
|
|
|
|
|
|
### సిద్ధంగా ఉండటం
|
|
|
|
|
|
గమనికగా, మీరు ఈ డేటాను లోడ్ చేయడం ఆ డేటాపై ప్రశ్నలు అడగడానికి సిధ్ధమవుతున్నారు.
|
|
|
|
|
|
- పంక్పిన్లు కొనడానికి ఉత్తమ సమయం ఎప్పుడు?
|
|
|
- మినియేచర్ పంక్పిన్ల కేసు ధర ఎంత ఆశించవచ్చు?
|
|
|
- వాటిని అర్థ బషెల్ కార్టన్లలో కొనాలా లేదా 1 1/9 బషెల్ బాక్స్ ద్వారా కొనాలా?
|
|
|
|
|
|
ఈ డేటాను మరింత అన్వేషించుకుందాం.
|
|
|
|
|
|
గత పాఠంలో, మీరు పాండాస్ డేటా ఫ్రేమ్ సృష్టించి, ఆదిలో భాగాన్నిఉండే డేటాసెట్ నుండి కొంత భాగాన్ని అద్దకెక్కించారు, ధరలను బషెల్ కు ప్రమాణీకరించారు. అయితే అది కేవలం సుమారు 400 డేటాపాయింట్ల వరకు మరియు కేవలం శరదృతువు నెలల వరకు మాత్రమే పరిమితం అయ్యింది.
|
|
|
|
|
|
ఈ పాఠంలో ప్రీ-లోడ్ చేసిన డేటాతో కూడిన నోట్బుక్ లో డేటాను చూడండి. డేటా ముందేనే లోడ్ చేసి, నెల డేటాను చూపించే ప్రారంభ స్కాటర్ప్లాట్ రూపొందించారు. మనం దాన్ని మరింత శుభ్రపరిచి డేటా స్వభావం గురించి మరింత వివరాలు దొరకొచ్చు.
|
|
|
|
|
|
## లీనియర్ రిగ్రెషన్ లైన్
|
|
|
|
|
|
పాఠం 1లో నేర్చుకున్నట్లుగా, లీనియర్ రిగ్రెషన్ వ్యాయామం యొక్క లక్ష్యం ఒక లైన్ ని ప్లోట్ చేయడమే:
|
|
|
|
|
|
- **లక్షణాల మధ్య సంబంధాలను చూపించాలి**. వేరియబుల్స్ మధ్య సంబంధాన్ని చూపించాలి
|
|
|
- **అంచనాలు చేయాలి**. కొత్త డేటాపాయింట్ ఆ లైన్ కింద ఎక్కడ పడుతుందో ఖచ్చితంగా అంచనా వేయాలి
|
|
|
|
|
|
**లీస్ట్-స్క్వాయర్స్ రిగ్రెషన్** సాధారణంగా ఇలాంటి రేఖను గీస్తుంది. "లీస్ట్-స్క్వాయర్స్" పదం మన మోడల్ లో సంపూర్ణ లోపాన్ని తగ్గించే ప్రక్రియకు సూచిస్తుంది. ప్రతి డాటాపాయింట్ కి, మనము ఉన్న లైన్ నుండి అసలు డాటాపాయింట్ మధ్య నిలువు దూరం (రెస్టిడ్యూల్) ను కొలుస్తాము.
|
|
|
|
|
|
మనం ఆ దూరాలను రెండు ముఖ్య కారణాల కోసం స్క్వేర్ (వరుస కీ పెడతాము):
|
|
|
|
|
|
1. **దిశ కన్నా పరిమాణం ముఖ్యం**: -5 లోపం, +5 లోపం సమానంగా చూడాలి. స్క్వేర్ చేయడం వల్ల అన్ని విలువలు పాజిటివ్ అవుతాయి.
|
|
|
|
|
|
2. **బాహ్య విలక్షణాలను శిక్షించడం**: పెద్ద లోపాలకు మరింత భారం ఇస్తుంది, తద్వారా లైన్ చాలా దూరంలో ఉన్న పాయింట్లకు దగ్గరగా ఉంటుంది.
|
|
|
|
|
|
తరువాత, అన్ని స్క్వేర్ విలువలను తిసికోవచ్చు. మన లక్ష్యం ఈ మొత్తాన్ని కనీసం చేసే నిర్దిష్ట రేఖను కనుగొనడం.
|
|
|
|
|
|
> **🧮 నాకు గణితం చూపించు**
|
|
|
>
|
|
|
> ఈ లైన్, _ఉత్తమ అనుపాత రేఖ_ అనే పేరు తో, [సమీయం ద్వారా వ్రాయబడుతుంది](https://en.wikipedia.org/wiki/Simple_linear_regression):
|
|
|
>
|
|
|
> ```
|
|
|
> Y = a + bX
|
|
|
> ```
|
|
|
>
|
|
|
> `X` అనేది 'వివరణాత్మక వేరియబుల్'. `Y` అనేది 'ఆధారిత వేరియబుల్'. లైన్ యొక్క వంపు `b` మరియు `a` అనేది y-ఇంటెర్ప్సెప్టు, అంటే `X = 0` ఉన్నప్పుడు `Y` విలువ.
|
|
|
>
|
|
|
>
|
|
|
>
|
|
|
> ముందుగా వంపు `b` ను గణించండి. ఇన్ఫోగ్రాఫిక్ [జెన్ లూపర్](https://twitter.com/jenlooper) చేత
|
|
|
>
|
|
|
> మరి, మన పంక్పిన్ డేటా యొక్క ప్రాథమిక ప్రశ్నను ఉద్దేశించి: "నెల వారీగా ఒక బషెల్ పంక్పిన్ ధరను అంచనా వేయండి", ఇక్కడ `X` ధరకి మరియు `Y` అమ్మకపు నెలకి సూచిస్తుందని అనుకోండి.
|
|
|
>
|
|
|
>
|
|
|
>
|
|
|
> Y విలువను గణించండి. మీరు సుమారు $4 చెల్లిస్తున్నారు అంటే, అది ఏప్రిల్ కావచ్చు! ఇన్ఫోగ్రాఫిక్ [జెన్ లూపర్](https://twitter.com/jenlooper) చేత
|
|
|
>
|
|
|
> లైన్ గణించే గణితం వంపును చూపించాలి, ఇది ఇంటెర్ప్సెప్టును ఆధారపడి ఉంటుంది, లేదా `X=0` ఉన్నప్పుడు `Y` స్థానం.
|
|
|
>
|
|
|
> ఈ విలువల గణనా పద్ధతి మీరు [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html) వెబ్ సైట్ లో చూడవచ్చు. అంకెలు లైను పై ప్రభావం ఎలా ఉందో చూసేందుకు [ఈ లీస్ట్-స్క్వాయర్స్ కాలిక్యులేటర్](https://www.mathsisfun.com/data/least-squares-calculator.html) ను కూడా సందర్శించండి.
|
|
|
|
|
|
## సంబంధం (కොරిలేషన్)
|
|
|
|
|
|
ఇంకో టెర్మ్ అర్థం చేసుకోవాలి అంటే **సంబంధ గుణకం** (Correlation Coefficient) ఒక X మరియు Y వేరియబుల్స్ కొరకు. స్కాటర్ప్లాట్ ఉపయోగించి మీరు దీన్ని తక్షణం చూడవచ్చు. ఒక ఆకర్షణీయమైన సరళమైన రేఖలో వివరించిన డేటాపాయింట్లు ఉన్న ప్లాట్ అధిక సంబంధాన్ని సూచిస్తుంది, కానీ X మరియు Y మధ్య అన్ని దిశలలో వ్యాపించిన పాయింట్లు ఉన్న ప్లాట్ తక్కువ సంబంధం ఉన్నదని సూచిస్తుంది.
|
|
|
|
|
|
చెత్తతక్కువ లోపాల లీస్ట్-స్క్వాయర్స్ రిగ్రెషన్ పద్ధతితో అధిక (0 కాకుండా 1కి సమీపంలో ఉన్న) సంబంధ గుణకం ఉన్న మోడల్ మంచి లీనియర్ రిగ్రెషన్ మోడల్ అవుతుంది.
|
|
|
|
|
|
✅ ఈ పాఠానికి తోడు ఉన్న నోట్బుక్ నడపండి మరియు నెల నుండి ధర వరకూ స్కాటర్ప్లాట్ పరిశీలించండి. మీరు చూసిన స్కాటర్ప్లాట్ ప్రకారం, పంక్పిన్ అమ్మకాల నెల మరియు ధర సంబంధం అధిక కొరకు లేదా తక్కువ కొరకు అనిపిస్తుందా? మీరు `నెల` కన్నా మరింత సున్నితమైన కొలత ఉపయోగిస్తే (ఉదా: *సంవత్సరపు రోజు* (అంటే సంవత్సర ప్రారంభం నుండి రోజుల సంఖ్య)), అది మారుతుందా?
|
|
|
|
|
|
క్రింది కోడ్ లో, మనం డేటాను శుభ్రం చేసామని, మరియు `new_pumpkins` అనే డేటా ఫ్రేమ్ తీసుకున్నామని అంగీకరిద్దాం, ఇది క్రింది విధంగా ఉంటుంది:
|
|
|
|
|
|
ID | నెల | సంవత్సరపు రోజు | జాతి | నగరం | ప్యాకేజీ | తక్కువ ధర | ఎక్కువ ధర | ధర
|
|
|
---|-------|-----------|---------|------|---------|-----------|------------|-------
|
|
|
70 | 9 | 267 | PIE TYPE | BALTIMORE | 1 1/9 బషెల్ కార్టన్లు | 15.0 | 15.0 | 13.636364
|
|
|
71 | 9 | 267 | PIE TYPE | BALTIMORE | 1 1/9 బషెల్ కార్టన్లు | 18.0 | 18.0 | 16.363636
|
|
|
72 | 10 | 274 | PIE TYPE | BALTIMORE | 1 1/9 బషెల్ కార్టన్లు | 18.0 | 18.0 | 16.363636
|
|
|
73 | 10 | 274 | PIE TYPE | BALTIMORE | 1 1/9 బషెల్ కార్టన్లు | 17.0 | 17.0 | 15.454545
|
|
|
74 | 10 | 281 | PIE TYPE | BALTIMORE | 1 1/9 బషెల్ కార్టన్లు | 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 "ML for beginners - Looking for Correlation: The Key to Linear Regression")
|
|
|
|
|
|
> 🎥 సంబంధం గురించి చిన్న వీడియో సమీక్ష కోసం పై చిత్రంపై క్లిక్ చేయండి.
|
|
|
|
|
|
గత పాఠం నుండి మీరు కనిపెట్టిన విధంగా, వేర్వేరు నెలల సగటు ధర ఇలా ఉంటుంది:
|
|
|
|
|
|
<img alt="Average price by month" src="../../../../translated_images/te/barchart.a833ea9194346d76.webp" width="50%"/>
|
|
|
|
|
|
ఇది కొంత సంబంధం ఉండాలని సూచిస్తుంది, మరియు మనం లీనియర్ రిగ్రెషన్ మోడల్ శిక్షణ ఇస్తూ, `నెల` మరియు `ధర` లేదా `సంవత్సరపు రోజు` మరియు `ధర` మధ్య సంబంధాన్ని అంచనా వేయవచ్చు. క్రింది స్కాటర్ప్లాట్ ఆ చివరివిషయాన్ని చూపుతుంది:
|
|
|
|
|
|
<img alt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/te/scatter-dayofyear.bc171c189c9fd553.webp" width="50%" />
|
|
|
|
|
|
`corr` ఫంక్షన్ ఉపయోగించి సంబంధం చూసేద్దాం:
|
|
|
|
|
|
```python
|
|
|
print(new_pumpkins['Month'].corr(new_pumpkins['Price']))
|
|
|
print(new_pumpkins['DayOfYear'].corr(new_pumpkins['Price']))
|
|
|
```
|
|
|
|
|
|
సంబంధం తక్కువగా -0.15 `నెల` పరిధిలో, మరియు -0.17 `DayOfMonth` లో ఉంది, కానీ మరొక ముఖ్యమైన సంబంధం ఉండొచ్చు. వివిధ పంక్పిన్ వేరియటీలకు వేర్వేరు ధర క్లస్టర్లు కనిపిస్తున్నాయి. ఈ ఊహను నిర్ధారించడానికి, ప్రతి వర్గానికి వేరే రంగు ఉపయోగించి స్కాటర్ప్లాట్ ప్లోట్ చేద్దాం. `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/te/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/te/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/te/pie-pumpkins-scatter.d14f9804a53f927e.webp" width="50%" />
|
|
|
|
|
|
`corr` ఫంక్షన్ ఉపయోగించి `ధర` మరియు `సంవత్సరపు రోజు` మధ్య సంబంధాన్ని లెక్కిస్తే, సుమారు `-0.27` వస్తుంది - అంటే శిక్షణ మోడల్ అంచనాకు అనుకూలం.
|
|
|
|
|
|
> లీనియర్ రిగ్రెషన్ మోడల్ శిక్షణకు ముందే, డేటా శుభ్రంగా ఉందని నిర్ధారించుకోవాలి. లీనియర్ రిగ్రెషన్ లో మిస్సింగ్ విలువలతో సమస్య ఉంటుంది, కాబట్టి ఖాళీ సెల్స్ తొలగించడం మంచిది:
|
|
|
|
|
|
```python
|
|
|
pie_pumpkins.dropna(inplace=True)
|
|
|
pie_pumpkins.info()
|
|
|
```
|
|
|
|
|
|
మరో మార్గం ఖాళీ విలువలను ఆ కాలమ్ యొక్క సగటు విలువతో భర్తీ చేయడమవుతుంది.
|
|
|
|
|
|
## సాదా లీనియర్ రిగ్రెషన్
|
|
|
|
|
|
[](https://youtu.be/e4c_UP2fSjg "ML for beginners - Linear and Polynomial Regression using 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 అర్రేలుగా విడగొడతాము:
|
|
|
|
|
|
```python
|
|
|
X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1)
|
|
|
y = pie_pumpkins['Price']
|
|
|
```
|
|
|
|
|
|
> గమనిక: లీనియర్ రిగ్రెషన్ ప్యాకేజీ సరిగా అర్థం చేసుకునేందుకు ఇన్పుట్ డేటాకు `reshape` నిర్వహించాల్సి వచ్చింది. లీనియర్ రిగ్రెషన్ 2D అర్రే అందుకోవాలని కోరుతుంది, ప్రతి వరుస ఒక లక్షణాల వెక్టార్కు సరిపోయింది. మన కేసులో, ఒకే ఒక ఇన్పుట్ ఉన్నందున N×1 శేప్ ఉన్న అర్రే కావాలి, ఇక్కడ 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)
|
|
|
```
|
|
|
|
|
|
`fit` చేసిన తర్వాత `LinearRegression` ఆబ్జెక్ట్ లో రిగ్రెషన్ యొక్క అన్నీ కోఎఫిషియెంట్లు ఉంటాయి, అవి `.coef_` ప్రాపర్టీ ద్వారా అక్సెస్ చేయవచ్చు. మన సందర్భంలో, ఒకే ఒక కోఎఫిషియెంట్ ఉంది, అది సుమారు `-0.017` ఉండాలి. అంటే ధరలు సమయానికి కొద్దిగా తగ్గుతున్నట్టు చూపిస్తుంది, కానీ చాలా కాదు, రోజుకు సుమారు 2 సెంట్లు వరకు. రిగ్రెషన్ యొక్క Y-అక్షాన్ని ఇంతర్సెక్షన్ పాయింట్ కూడా `lin_reg.intercept_` ద్వారా క్రిందిచూడవచ్చు - ఇది మన కేసులో సుమారు `21` ఉంటుంది, సంవత్సరం ఆరంభంలో ధరను సూచిస్తుంది.
|
|
|
|
|
|
మన మోడల్ ఎంత ఖచ్చితమో చూసేందుకు, మనం టెస్ట్ డేటాసెట్ పై ధరలను అంచనా వేయవచ్చు, ఆ తరువాత మన అంచనాలు అనుకూల విలువలకు ఎంత దగ్గరలో ఉందో కొలవచ్చు. దీన్ని రూట్ మీన్ స్క్వేర్ ఎర్రర్ (RMSE) metrics ఉపయోగించి చేయవచ్చు, ఇది అనుకున్న మరియు అంచనా విలువల మధ్య అన్ని స్క్వేర్ చేసిన తేడాల మీన్ యొక్క రూట్.
|
|
|
|
|
|
```python
|
|
|
pred = lin_reg.predict(X_test)
|
|
|
|
|
|
rmse = np.sqrt(mean_squared_error(y_test,pred))
|
|
|
print(f'RMSE: {rmse:3.3} ({rmse/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/te/linear-results.f7c3552c85b0ed1c.webp" width="50%" />
|
|
|
|
|
|
## పాలినోమియల్ రిగ్రెషన్
|
|
|
|
|
|
మరొకరకంగా లీనియర్ రిగ్రెషన్ అంటే పాలినోమియల్ రిగ్రెషన్. మారకాల మధ్య కొన్నిసార్లు లీనియర్ సంబంధం ఉంటే—పంప్కిన్ వాల్యూమ్ ఎక్కువగా ఉంటే ధర ఎక్కువగా ఉండడం వంటివి—కొన్నిసార్లు ఈ సంబంధాలని సూటిగా లేదా విమానంగా చూపించడం కష్టం.
|
|
|
|
|
|
✅ ఇక్కడ కొన్ని మరిన్ని ఉదాహరణలు ఉన్నాయి [https://online.stat.psu.edu/stat501/lesson/9/9.8](https://online.stat.psu.edu/stat501/lesson/9/9.8) పాలినోమియల్ రిగ్రెషన్ ఉపయోగించవచ్చిన డేటా గురించి
|
|
|
|
|
|
తేదీ మరియు ధర మధ్య సంబంధాన్ని మరోసారి పరిశీలించండి. ఈ స్కాటర్ప్లాట్ తప్పకుండా సూటిగా విశ్లేషించాలి అనిపిస్తుందా? ధరలు అతిశయంగా మారవచ్చా? ఈ సందర్భంలో, పాలినోమియల్ రిగ్రెషన్ ప్రయత్నించవచ్చు.
|
|
|
|
|
|
✅ పాలినోమియల్స్ అనేవి గణిత సంబంధాలు, ఇవి ఒకటి కంటే ఎక్కువ వేరియబుల్స్ మరియు కోఎఫిషియెంట్లతో ఉండవచ్చు
|
|
|
|
|
|
పాలినోమియల్ రిగ్రెషన్ అప్రత్యక్ష డేటాతో మంచి సరిపోయే వంకర గraphను సృష్టిస్తుంది. మన కేసులో, `DayOfYear` వేరియబుల్ యొక్క వర్గమూలాన్ని ఇన్పుట్ లో చేర్చితే, మన డేటాను ఒక పారబాలిక్ వంకరతో సరిపెట్టవచ్చు, ఇది సంవత్సరంలో ఒక నిర్దిష్ట స్థలంలో కనిష్టం కలిగివుంటుంది.
|
|
|
|
|
|
Scikit-learn సహాయకమైన [pipeline API](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) ను కలిపి వేరే డేటా ప్రాసెసింగ్ స్టెప్పులను కలపడానికి వాడుతుంది. ఒక **pipeline** అనేది **estimators** చైన్. మనం మొదట పాలినోమియల్ ఫీచర్స్ మన మోడల్ లో చేర్చి, తరువాత రిగ్రెషన్ శిక్షణ ఇస్తాం:
|
|
|
|
|
|
```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> ను కూడా చేర్చుతుంది. మనం కావాలంటే ఎక్కువ అర్ధం గల పాలినోమియల్స్ కూడా ఉపయోగించవచ్చు.
|
|
|
|
|
|
Pipeline లను మొదటి `LinearRegression` ఆబ్జెక్ట్ లాగా ఉపయోగించవచ్చు, అంటే pipeline పై `fit` చేసి, తరువాత `predict` తో అంచనా ఫలితాలు పొందవచ్చు. ఇక్కడ టెస్ట్ డేటా మరియు సమీపీకరణ వంకర చూపబడింది:
|
|
|
|
|
|
<img alt="Polynomial regression" src="../../../../translated_images/te/poly-results.ee587348f0f1f60b.webp" width="50%" />
|
|
|
|
|
|
పాలినోమియల్ రిగ్రెషన్ ఉపయోగించి, కొంత తక్కువ MSE మరియు ఎక్కువ నిర్ణయ కోఎఫిషియెంట్ పొందవచ్చు, కానీ పెద్దభాగంగా కాదు. ఇంకొన్ని లక్షణాలు పరిగణించాలి!
|
|
|
|
|
|
> నూతనంగా, కంటిపప్పు ధరలు సాధారణంగా హాలోవీన్ సమీపంలో తక్కువగా ఉంటాయి. దీని కారణం ఏమిటి?
|
|
|
|
|
|
🎃 అభినందనలు, మీరు పాయ్ పంప్కిన్ ధర అంచనా వేయడానికి ఒక మోడల్ సృష్టించారు. మీరు వేరే అన్ని పంప్కిన్ రకాలకు కూడా ఇదే విధానం అనుసరించవచ్చు, కానీ అది బరువు పని అవుతుంది. ఇప్పుడు మనం పంప్కిన్ రకాన్ని మన మోడల్ లో ఎలా పరిగణించాలో నేర్చుకుందాం!
|
|
|
|
|
|
## వర్గీకృత లక్షణాలు
|
|
|
|
|
|
సంపూర్ణ ప్రపంచంలో, వేరే పంప్కిన్ రకాల ధరలను ఒకే మోడల్ ద్వారా అంచనా వేయగలగాలి. కానీ, `Variety` కాలమ్ కొన్ని రకాల విలువలను కలిగి ఉంటుంది, ఉదాహరణకి సంఖ్యలేం కాదు. అటువంటి కాలమ్స్ ని **categorical** అంటారు.
|
|
|
|
|
|
[](https://youtu.be/DYGliioIAE0 "ML for beginners - Categorical Feature Predictions with Linear Regression")
|
|
|
|
|
|
> 🎥 పై చిత్రంపై క్లిక్ చేసి వర్గీకృత లక్షణాలు ఉపయోగించడం గురించికొత్త వీడియో చూపించండి.
|
|
|
|
|
|
ఇక్కడ మీరు చూస్తారు, సగటు ధర రకం పై ఆధారపడి ఉంటుంది:
|
|
|
|
|
|
<img alt="Average price by variety" src="../../../../translated_images/te/price-by-variety.744a2f9925d9bcb4.webp" width="50%" />
|
|
|
|
|
|
రకాన్ని పరిగణించేందుకు, మునుపటి సంఖ్య రూపంలో మార్చాలి, దీన్ని **encode** అంటారు. దీని కొరకు ఎన్నో మార్గాలు ఉన్నాయి:
|
|
|
|
|
|
* సింపుల్ **న్యూమరిక్ ఎన్కోడింగ్** వేర్వేరు రకాల పట్టికని తయారు చేసి, ఆ రకం పేరును సూచికతో భర్తీ చేస్తుంది. లీనియర్ రిగ్రెషన్ కోసం ఇది మంచి ఆలోచన కాదు, ఎందుకంటే రిగ్రెషన్ సూచిక సంఖ్య యొక్క అసలు సంఖ్యను తీసుకుంటుంది మరియు ఫలితానికి ఒక కొఫిషియెంట్ తో గుణిస్తుంది. మన కేసులో, సూచిక సంఖ్య మరియు ధర మధ్య సంబంధం స్పష్టంగా లీనియర్ కాదు, సూచికలు ఏ విధంగా వరుసబద్దం చేసినా సరే.
|
|
|
* **వన్-హాట్ ఎన్కోడింగ్** `Variety` కాలమ్ ని 4 విడి కాలమ్స్ గా భర్తీ చేస్తుంది, ఒక్కో రకానికి ఒకటి. ప్రతి కాలమ్ లో, సంబంధిత వరుస ఆ రకానికి చెందినదైతే `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% అంచనా పొరపాటు) ఇస్తుంది.
|
|
|
|
|
|
| Model | MSE | Determination |
|
|
|
|-------|-----|--------------|
|
|
|
| `DayOfYear` Linear | 2.77 (17.2%) | 0.07 |
|
|
|
| `DayOfYear` Polynomial | 2.73 (17.0%) | 0.08 |
|
|
|
| `Variety` Linear | 5.24 (19.7%) | 0.77 |
|
|
|
| All features Linear | 2.84 (10.5%) | 0.94 |
|
|
|
| All features Polynomial | 2.23 (8.25%) | 0.97 |
|
|
|
|
|
|
🏆 బాగుంది! మీరు ఒక పాఠంలో నాలుగు రిగ్రెషన్ మోడల్స్ తయారుచేసి, నాణ్యతను 97% కి పెంచేశారు. రిగ్రెషన్ చివరి భాగంలో, మీరు వర్గాలను నిర్ణయించే లాజిస్టిక్ రిగ్రెషన్ గురించినది నేర్పుకోనున్నారు.
|
|
|
|
|
|
---
|
|
|
## 🚀సవాల్
|
|
|
|
|
|
ఈ నోట్బుక్ లో వివిధ వేరియబుల్స్ ని పరీక్షించి, అవి మోడల్ ఖచ్చితత్వం కి సంబంధించి ఎలా ఉంటాయో చూడండి.
|
|
|
|
|
|
## [పోస్టు-లెక్షర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
|
|
|
|
|
|
## సమీక్ష & స్వీయ అధ్యయనం
|
|
|
|
|
|
ఈ పాఠంలో మనం లీనియర్ రిగ్రెషన్ గురించి నేర్చుకున్నాం. ఇతర ముఖ్య రిగ్రెషన్ రకాలూ ఉన్నాయి. స్టెప్వైజ్, రిడేజ్, లాస్సో మరియు ఎలాస్టిక్నెట్ టెక్నిక్స్ గురించి చదవండి. మరింత నేర్చుకోవడానికి మంచి కోర్సు [స్టాన్ఫోర్డ్ స్టాటిస్టికల్ లెర్నింగ్ కోర్సు](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning)గా ఉంది.
|
|
|
|
|
|
## అసైన్మెంట్
|
|
|
|
|
|
[మోడల్ నిర్మించండి](assignment.md)
|
|
|
|
|
|
---
|
|
|
|
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
|
|
|
**గమనిక**:
|
|
|
ఈ డాక్యూమెంట్ [Co-op Translator](https://github.com/Azure/co-op-translator) AI అనువాద సేవను ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వం కోసం ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా అసత్యతలు ఉండవచ్చు. మౌలిక భాషలో ఉన్న అసలు డాక్యూమెంట్ ను అధికారిక స్రోతస్ఫూర్తిగా పరిగణించాలి. కీలక సమాచారం కోసం, వృత్తిపరమైన మానవ అనువాదాన్ని సూచించబడుతుంది. ఈ అనువాదం ఉపయోగం నుండి వచ్చేప్రమాదాలు లేదా తప్పుదొర్లికలకు మేము బాధ్యత వహించడానికి లేదు.
|
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER END --> |
