# បង្កើតម៉ូឌែលផ្សារដោយប្រើ Scikit-learn: ផ្សារបួនរបៀប
## សម្គាល់សម្រាប់អ្នកចាប់ផ្ដើម
ការផ្សាររៀបរ៉េឌីស្យុងត្រូវបានប្រើនៅពេលដែលយើងចង់ទាយទោលតម្លៃ **ចំនួនស៊ីផ៍** (ឧទាហរណ៍ តម្លៃផ្ទះ, សីតុណ្ហភាព ឬ លក់ចេញ)។ វាដំណើរការដោយស្វែងរករបារភាពតម្រាស់មួយដែលតំណាងឲ្យទំនាក់ទំនងរវាងលក្ខណៈបញ្ចូល និងលទ្ធផលបានល្អបំផុត។
នៅក្នុងមេរៀននេះយើងផ្តោតលើការយល់ដឹងពីគំនិតមុនពេលស្រាវជ្រាវបច្ចេកវិទ្យាស្រាវជ្រាវផ្សារលំដាប់ខ្ពស់បន្ថែមទៀត។
> រូបភាពព័ត៌មានដោយ [Dasani Madipalli](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 កំប៉ិល?
អើយ! យើងសូមលត់ចូលទៅក្នុងទិន្នន័យនេះបន្ថែម។
ក្នុងមេរៀនមុន អ្នកបានបង្កើតតារាងតំណាង Pandas ហើយផ្ទុកវានៅជុំវិញផ្នែកមួយនៃឯកសារដើម ដោយប្រើការតម្រឹមតម្លៃផ្ទាល់មួយកំប៉ិល។ ប៉ុន្តែបច្ចុប្បន្ននេះ អ្នកអាចប្រមូលបានត្រឹមតែប្រហែល ៤០០ចំណុចទិន្នន័យហើយត្រឹមតែសម្រាប់ខែរដូវស្លឹកឈើជ្រុះតែប៉ុណ្ណោះ។
មើលទិន្នន័យដែលបានផ្ទុករួចជាមុនក្នុងកំណត់ត្រារួមនៅក្នុងមេរៀននេះ។ ទិន្នន័យត្រូវបានផ្ទុករួចហើយ និងបានចុះតំណាងតាមរយៈ scatterplot ដើម្បីបង្ហាញទិន្នន័យតាមខែ។ ប្រហែលជាយើងអាចយកព័ត៌មានជាក់លាក់បន្ថែមអំពីលក្ខណៈទិន្នន័យដោយសម្អាតវាបន្ថែមទៀត។
## សន្ទស្សន៍ផ្សាររៀបរាប់រាងតែមួយ
ដូចដែលអ្នកបានរៀនក្នុងមេរៀន១ គោលបំណងនៃសមាហរណកម្ម Linear Regression គឺដើម្បីគូសបន្ទាត់មួយដែល:
- **បង្ហាញទំនាក់ទំនងអថេរ**។ បង្ហាញទំនាក់ទំនងរវាងអថេរ
- **ធ្វើការទាយទោល**។ ធ្វើការទាយទោលយ៉ាងត្រឹមត្រូវថាចំណុចទិន្នន័យថ្មីនឹងស្ថិតនៅកន្លែងណាជិតបន្ទាត់នោះ។
សិក្សារៀបរាប់ប្រើមធ្យោបាយ **Least-Squares Regression** ជាទូទៅក្នុងការគូសបន្ទាត់ប្រភេទនេះ។ ពាក្យ "Least-Squares" មានន័យពីដំណើរការកាត់បន្ថយកំហុសសរុបក្នុងម៉ូឌែលយើង។ សម្រាប់ចំណុចទិន្នន័យរាល់គឺយើងវាស់ចម្ងាយឈរ (ហៅថា residual) រវាងចំណុចពិត និងបន្ទាត់ផ្សារ។
យើងសម្រួលចម្ងាយទាំងនេះដល់កំរិតក្រោមពីហេតុផលពីរចម្បង៖
1. **ទំហំលើទិសដៅ**៖ យើងចង់ដាក់តម្លៃកំហុស -5 និង +5 ដូចគ្នា។ ការបង្រួចគុណបង្កើតអោយតម្លៃទាំងអស់ជាស្រប។
2. **ពិនិត្យសំណុំនៃចំណុចក្រៅ**៖ ការបង្រួចគុណធ្វើឲ្យកំហុសធំៗទទួលបានទំងន់ច្រើនជាង ហើយបណ្តាលឲ្យបន្ទាត់នៅជិតចំណុចចម្ងាយ។
បន្ទាប់មកយើងបូកតម្លៃក្រោមគុណទាំងនេះទាំងឡាយគ្នា។ គោលដៅគឺរកបន្ទាត់ជាក់លាក់មួយដែលបូកចុងក្រោយនេះតិចជាងគេ (តម្លៃតិចបំផុត)—ហេតុនេះហៅថា "Least-Squares"។
> **🧮 បង្ហាញគណិតវិទ្យា**
>
> បន្ទាត់នេះ ដែលហៅថា _បន្ទាត់ត្រូវគ្នា_ អាចបញ្ចេញដោយ[សមីការ](https://en.wikipedia.org/wiki/Simple_linear_regression):
>
> ```
> Y = a + bX
> ```
>
> `X` គឺជា 'អថេរពន្យល់'។ `Y` គឺជា 'អថេរពឹងផ្អែក'។ លំនឹងបន្ទាត់គឺ `b` ហើយ `a` គឺ កន្លែងឆ្លងដែក y-intercept ដែលសំដៅតម្លៃ `Y` នៅពេល `X = 0`។
>
>
>
> ជំហានដំបូង គណនាលំនឹង `b`។ រូបភាពព័ត៌មានដោយ [Jen Looper](https://twitter.com/jenlooper)
>
> ផ្ទុះពីនេះ និងបើសិនវាចង់បង្ហាញពីសំណួរដើមទិន្នន័យផ្លែផ្អែខោច៖ "ទាយតម្លៃផ្លែផ្អែខោចមួយក្នុងមួយកំប៉ិល តាមខែ" គឺ `X` នឹងសំដៅតម្លៃ និង `Y` នឹងសំដៅខែក្នុងការលក់។
>
>
>
> គណនាតម្លៃ `Y`។ ប្រសិនបើអ្នកប្រាក់តម្លៃប្រហែល $4 វាត្រូវតែជាខែ មេសា! រូបភាពព័ត៌មានដោយ [Jen Looper](https://twitter.com/jenlooper)
>
> គណិតវិទ្យាដែលគណនាបន្ទាត់ត្រូវបង្ហាញលំនឹងបន្ទាត់ ដែលត្រូវអាស្រ័យលើការឆ្លងដែក ឬកន្លែងដែល `Y` មានតម្លៃនៅពេល `X = 0`។
>
> អ្នកអាចមើលវិធីសាស្រ្តគណនាចំនួនទាំងនេះនៅគេហទំព័រ [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html)។ បន្ថែមទៀត អ្នកអាចចូលមើល [លេខាគណនាតាម Least-squares](https://www.mathsisfun.com/data/least-squares-calculator.html) ដើម្បីងាយយល់ពីរបៀបលេខមានឥទ្ធិពលដល់បន្ទាត់។
## ទំនាក់ទំនងសមាមាត្រ (Correlation)
ពាក្យមួយទៀតដែលត្រូវយល់គឺ **សមាមាត្រជាគូ** រវាងអថេរ X និង Y។ អ្នកអាចមើលសមាមាត្រនេះបានយ៉ាងរហ័សតាមការគូស scatterplot។ ប្លាត់ដែលមានចំណុចរាយព្រមទ្រុងក្នុងបន្ទាត់ត្រូវមានសមាមាត្រខ្ពស់ ប៉ុន្តែប្លាត់ដែលចំណុចរាយឡើងគ្នារវាង X និង Y គឺមានសមាមាត្រតិច។
ម៉ូឌែលផ្សារ Linear Regression ល្អគឺបានសមាមាត្រខ្ពស់ (ជិត 1 ជាង 0) ដោយប្រើវិធីសាស្រ្ត Least-Squares Regression ជាមួយបន្ទាត់ផ្សារ។
✅ រត់កំណត់ត្រាជាមួយមេរៀននេះ រួចមើល scatterplot សមាមាត្រពី Month ទៅ Price។ តើទិន្នន័យដែលភ្ជាប់ Month ទៅ Price សម្រាប់ការលក់ផ្លែផ្អែខោច យល់ថាសមាមាត្រខ្ពស់ឬទាប តាមការពិចារណារបស់អ្នកលើ scatterplot? តើវាប្រែប្រួលប្រសិនបើអ្នកប្រើវិមាត្រចំណាស់ជាងមុន ហៅថា *ថ្ងៃនៃឆ្នាំ* (ចំនួនថ្ងៃចាប់ពីដើមឆ្នាំ)?
ក្នុងកូដខាងក្រោម នឹងគិតថាអ្នកបានសម្អាតទិន្នន័យហើយ ហើយទទួលបាន data frame មានឈ្មោះ `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 "ML for beginners - Looking for Correlation: The Key to Linear Regression")
> 🎥 ចុចរូបភាពខាងលើសម្រាប់មើលវីដេអូសង្ខេបអំពីទំនាក់ទំនងសមាមាត្រ។
ពីមេរៀនមុន អ្នកប្រហែលជាបានឃើញថាតម្លៃមធ្យមសម្រាប់ខែផ្សេងៗមើលទៅដូចជា:
នេះបង្ហាញថាគួរតែមានទំនាក់ទំនងមួយ និងយើងអាចសាកល្បងបណ្តុះម៉ូឌែល Linear Regression ដើម្បីទាយទំនាក់ទំនងរវាង `Month` និង `Price` ឬស្របពេល `DayOfYear` និង `Price`។ នេះជាការបង្ហាញទិន្នន័យ scatterplot មួយបង្ហាញពីទំនាក់ទំនងចុងក្រោយ៖
យើងមកមើលថាតើមានទំនាក់ទំនងសមាមាត្រដែលប្រើបានតាម `corr` function ដែរឬ?
```python
print(new_pumpkins['Month'].corr(new_pumpkins['Price']))
print(new_pumpkins['DayOfYear'].corr(new_pumpkins['Price']))
```
មើលទៅសមាមាត្រមានតិច គឺ -0.15 សម្រាប់ `Month` និង -0.17 សម្រាប់ `DayOfMonth` ប៉ុន្តែអាចមានទំនាក់ទំនងសំខាន់ផ្សេងទៀត។ វាមើលទៅដូចជាមានក្រុមតម្លៃផ្សេងៗរបស់ផ្លែផ្អែខោចផ្សេងៗ។ ដើម្បីបញ្ជាក់សំណល់នេះ យើងមកគូសម៉ូដែលផ្លែផ្អែខោចនីតិវិធីដោយពណ៌ផ្សេងៗគ្នា។ ដោយបញ្ជូនប៉ារ៉ាម៉ែត្រ`ax` ទៅកម្មវិធីគូស scatterplot អ្នកអាចគូសចំណុចទាំងអស់នៅលើតារាងតែមួយ។
```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)
```
ការស៊ើបអង្កេតនិងបង្ហាញថាប្រភេទផ្លែប៉ះពាល់ជាងកាលបរិច្ឆេទលក់។ អ្នកអាចមើលមើលវាពីក្រាលបន្ទាត់ចំនួនជាប់គ្នា៖
```python
new_pumpkins.groupby('Variety')['Price'].mean().plot(kind='bar')
```
យើងយកចំណុចមានចំណាប់អារម្មណ៍មួយ គឺ ‘pie type’ និងមើលឥទ្ធិពលរបស់កាលបរិច្ឆេទលើតម្លៃ៖
```python
pie_pumpkins = new_pumpkins[new_pumpkins['Variety']=='PIE TYPE']
pie_pumpkins.plot.scatter('DayOfYear','Price')
```
បើយើងគណនាសមាមាត្ររវាង `Price` និង `DayOfYear` ដោយប្រើ `corr` វានឹងត្រឹមតែប្រហែលជា `-0.27` - មានន័យថាការបណ្តុះម៉ូឌែលទាយទោលមានទំនាក់ទំនងហើយ។
> មុននឹងបណ្តុះម៉ូឌែល Linear Regression វាជារឿងសំខាន់ក្នុងការត្រួតពិនិត្យថាទិន្នន័យរបស់យើងបានស្អាត។ Linear Regression មិនប្រសើរជាមួយអថេរបាត់បង់ ដូច្នេះវាត្រូវបានណែនាំឲ្យកម្ចាត់អថេរទទេទាំងអស់៖
```python
pie_pumpkins.dropna(inplace=True)
pie_pumpkins.info()
```
មុខងារផ្សេងគ្នាគឺដាក់បញ្ចូលតម្លៃទទេនូវតម្លៃមធ្យមពីជួរឈរត្រូវទាក់ទង។
## ផ្សាររៀបរាប់រាងតែមួយសាមញ្ញ
[](https://youtu.be/e4c_UP2fSjg "ML for beginners - Linear and Polynomial Regression using Scikit-learn")
> 🎥 ចុចរូបភាពខាងលើសម្រាប់មើលវីដេអូទាំងមូលអំពីការបណ្តុះម៉ូឌែល Linear និង Polynomial Regression។
ដើម្បីបណ្តុះម៉ូឌែល Linear Regression របស់យើង យើងនឹងប្រើបណ្ណាល័យ **Scikit-learn**។
```python
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split
```
យើងចាប់ផ្ដើមដោយបំបែកចំនួនបញ្ចូល (features) និងចេញរង់ចាំ (label) ទៅជា array numpy ផ្សេងៗ៖
```python
X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1)
y = pie_pumpkins['Price']
```
> សម្គាល់ថាយើងត្រូវ reshape ទិន្នន័យបញ្ចូល ដើម្បីឲ្យ package Linear Regression យល់បានត្រឹមត្រូវ។ Linear Regression រង់ចាំ input array 2D ដែលជាតួរទំាងរបស់ជួរឈរនីមួយៗជាតួរផ្គុំឡើង ដូច្នេះសម្រាប់ input តែមួយ យើងចង់បាន array ទំហំ N×1 ដែល N គឺទំហំទិន្នន័យ។
បន្ទាប់មក យើងត្រូវបែងចែកទិន្នន័យជា train និង test dataset ដើម្បីធានាការផ្ទៀងផ្ទាត់ម៉ូឌែលបន្ទាប់ពីបណ្តុះ៖
```python
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
```
ចុងក្រោយ ការបណ្តុះម៉ូឌែល Linear Regression ជាក់ស្តែង ត្រូវការតែពីរបន្ទាត់កូដ។ យើងកំណត់វត្ថុ `LinearRegression` ហើយភ្ជាប់វានៅលើទិន្នន័យដោយវិធីសាស្រ្ត `fit`៖
```python
lin_reg = LinearRegression()
lin_reg.fit(X_train,y_train)
```
Object `LinearRegression` បន្ទាប់ពីបាន `fit` រួចមានគុក័ភីស្យង់ទាំងអស់នៃរេហ្គ្រេស្យុង ដែលអាចចូលប្រើបានដោយប្រើបច្ចេក `.coef_`។ ក្នុងករណីរបស់យើង មានគុក័ភីស្យង់តែ១ ដែលគួរតែប្រហែល `-0.017`។ វាមានន័យថា តម្លៃថ្លៃទំនិញមានន័យថាកំពុងធ្លាក់បន្តិចបន្តួចជាមួយពេលវេលា ប៉ុន្តែមិនចាញ់ខ្លាំង ត្រឹមប្រហែល ២ សេនក្នុងមួយថ្ងៃទេ។ យើងក៏អាចចូលប្រើចំណុចឆ្លងផ្តួចផ្តើមរបស់រេហ្គ្រេស្យុងជាមួយអ័ក្ស Y ដោយប្រើ `lin_reg.intercept_` ដែលនៅក្នុងករណីរបស់យើងនឹងប្រហែល `21` ដែលបង្ហាញពីតម្លៃថ្លៃលើកដំបូងនៃឆ្នាំ។
ដើម្បីមើលថាម៉ូដែលរបស់យើងមានភាពត្រឹមត្រូវប៉ុណា យើងអាចទាយទម្លៃថ្លៃទំនិញលើប្រភេទទិន្នន័យសាកល្បង ហើយបន្ទាប់មកវាស់ថាតម្លៃទាយរបស់យើងជិតតម្លៃដែលរំពឹងទុកប៉ុណ្ណា។ វាអាចធ្វើបានដោយប្រើតំលៃ MSE (mean square error) ដែលជាមធ្យមនៃខុសគ្នារវាងតម្លៃរំពឹងទុក និងតម្លៃទាយដែលបានក្រោមភាពឡើងវិញ។
```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}%)')
```
កំហុសរបស់យើងឆ្ងាយប្រហែល ២ ពិន្ទុ ដែលជាប្រហែល ~17%។ មិនល្អពេកទេ។ សញ្ញាមួយទៀតនៃគុណភាពម៉ូដែលគឺ **coefficient of determination** ដែលអាចទទួលបានដូចខាងក្រោម៖
```python
score = lin_reg.score(X_train,y_train)
print('Model determination: ', score)
```
បើតម្លៃនេះស្មើ 0 មានន័យថាម៉ូដែលមិនយកទិន្នន័យបញ្ចូលចូលចិត្តនោះទេ ហើយគាត់ប្រតិបត្តិដូចជា *អ្នកទាយបង្ហាញបញ្ចូល linear អាក្រក់បំផុត* ដែលគ្រាន់តែជាតម្លៃមធ្យមនៃលទ្ធផល។ តម្លៃ 1 មានន័យថាយើងអាចទាយទម្លៃលទ្ធផលបានយ៉ាងពេញលេញ។ ក្នុងករណីរបស់យើង coefficient ប្រហែល 0.06 ដែលទាបបន្តិច។
យើងក៏អាចបង្ហាញទិន្នន័យសាកល្បង រួមជាមួយខ្សែរេហ្គ្រេស្យុង ដើម្បីឲ្យយល់ច្បាស់ថារេហ្គ្រេស្យុងធ្វើការយ៉ាងដូចម្តេច៖
```python
plt.scatter(X_test,y_test)
plt.plot(X_test,pred)
```
## រេហ្គ្រេស្យុងផូលីណូម្យ얼
ប្រភេទមួយទៀតនៃរេហ្គ្រេស្យុងបែបជួរឈរជាមួយគ្នាគឺ រេហ្គ្រេស្យុងផូលីណូម្យ얼។ នៅពេលខ្លះ មានទំនាក់ទំនងបែបជួរឈរពីរវីរីables - ដូចជាឥដ្ឋមានទំហំនាងធំ នឹងមានតម្លៃថ្លៃខ្ពស់ជាង - ប៉ុន្តេលើកលែងទំនាក់ទំនងទាំងនេះមិនអាចបង្ហាញជាពហុប្លង់ ឬបន្ទាត់ស្របបាន។
✅ នៅទីនេះមាន [ឧទាហរណ៍បន្ថែម](https://online.stat.psu.edu/stat501/lesson/9/9.8) នៃទិន្នន័យដែលអាចប្រើរេហ្គ្រេស្យុងផូលីណូម្យ얼បាន
សូមមើលទំនាក់ទំនងរវាងថ្ងៃ និងតម្លៃវិញ។ តើក្រាហ្វ Scatterplot នេះមើលទៅគឺត្រូវតែវិភាគដោយបន្ទាត់ស្របទេមែន? តើតម្លៃថ្លៃអាចមានការប្រែប្រួលទេ? ក្នុងករណីនេះ អ្នកអាចសាកល្បងរេហ្គ្រេស្យុងផូលីណូម្យ얼បាន។
✅ ផូលីណូម្យ얼គឺជាការសម្ដែងគ្រឹះគណិតវិទ្យាដែលអាចមានអថេរតែមួយ ឬច្រើន និងគុក័ភីស្យង់
រេហ្គ្រេស្យុងផូលីណូម្យ얼បង្កើតខ្សែពោងកោង ដើម្បីឲ្យអាចសាកសមនឹងទិន្នន័យមិនម៉ាស្សា linear បានល្អប្រសើរជាងមុន។ ក្នុងករណីរបស់យើង ប្រសិនបើបញ្ចូលអថេរពណ៌វត្ថុ `DayOfYear`^2 ទៅក្នុងទិន្នន័យបញ្ចូល យើងគួរតែអាចតំឡើងទិន្នន័យជាមួយខ្សែ parabola ដែលមានតម្លៃអប្បបរមានៅពេលកំណត់មួយក្នុងឆ្នាំ។
Scikit-learn មាន [pipeline API](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) ដែលមានប្រយោជន៍ ដើម្បីតភ្ជាប់ជំហានដំណើរការទិន្នន័យផ្សេងៗគ្នា។ **pipeline** គឺជាសង្ស័យនៃ **estimators**។ ក្នុងករណីរបស់យើង យើងនឹងបង្កើត 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`^2 ប៉ុណ្ណោះ ប៉ុន្តែបើមានអថេរ 2 គឺ X និង Y វានឹងបន្ថែម X^2, XY និង Y^2 ក៏បាន។ យើងអាចប្រើផូលីណូម្យ얼ជំពូកខ្ពស់ ដោយបើត្រូវការបានដែរ។
pipeline អាចប្រើប្រាស់បានដូចជាអង្គភាព `LinearRegression` ដើម ដូច្នេះយើងអាច `fit` pipeline ហើយបន្ទាប់មកប្រើ `predict` បានផងដែរ ដើម្បីទទួលលទ្ធផលទាយ។ ខាងក្រោមជាក្រាហ្វដែលបង្ហាញទិន្នន័យសាកល្បង និងខ្សែពោងកោងតំណាង៖
ដោយប្រើរេហ្គ្រេស្យុងផូលីណូម្យ얼 យើងអាចទទួលបាន MSE ទាបជាងបន្តិច និង coefficient of determination ខ្ពស់ជាងបន្តិច ប៉ុន្តែមិនខ្លាំងណាស់ទេ។ យើងត្រូវយកចំណុចផ្សេងទៀតចូលក្នុងការពិចារណាផងដែរ!
> អ្នកអាចបើកចំណាំបានថា តម្លៃថ្លៃអង្គរជាមួយខ្នងនោះមានចន្លោះពេលដែលជិតថ្ងៃ Halloween។ តើអ្នកអាចពន្យល់មូលហេតុនេះបានយ៉ាងដូចម្តេច?
🎃 សូមអបអរសាទរ អ្នកទើបបង្កើតម៉ូដែលមួយដែលអាចជួយទាយតម្លៃថ្លៃនំទំពាំងបាយជូបាន។ អ្នកប្រហែលជាអាចធ្វើដំណើរការតែមួយនេះសម្រាប់ប្រភេទទំពាំងបាយជូគ្រប់ប្រភេទបានផង ប៉ុន្តែវាត្រូវការការងារលំបាក។ យើងនឹងរៀនរបៀបយកប្រភេទទំពាំងបាយជូទៅក្នុងគំរូរបស់យើងឥលូវនេះ!
## លក្ខណៈពិសេសដូចជាប្រភេទ (Categorical Features)
នៅក្នុងពិភពផ្តល់ក្តីសង្ឃឹម អ្នកចង់អាចទាយតម្លៃថ្លៃសម្រាប់ប្រភេទទំពាំងបាយជូផ្សេងៗដោយប្រើម៉ូដែលតែមួយ។ ប៉ុន្តែកន្លែងជួរឈរ `Variety` មានភាពខុសគ្នាពីជួរឈរ `Month` ប៉ុន្តែបង្កប់តម្លៃមិនមែនជាតួលេខទេ។ ជួរឈរដូចនេះហៅថា **categorical**។
[](https://youtu.be/DYGliioIAE0 "ML for beginners - Categorical Feature Predictions with Linear Regression")
> 🎥 ចុចរូបភាពខាងលើសម្រាប់វីដេអូជាសង្ខេបអំពីការប្រើលក្ខណៈពិសេសឈ្មោះដូចជាប្រភេទ។
នៅទីនេះ អ្នកអាចមើលថាតម្លៃថ្លៃមធ្យមអាស្រ័យលើប្រភេទ៖
ដើម្បីយកប្រភេទចូលក្នុងគំរូបាន ត្រូវបម្លែងវាទៅជាទម្រង់លេខឬ **encode**វា។ មានវិធីជាច្រើនក្នុងការធ្វើៈ
* **numeric encoding** សាមញ្ញ នឹងបង្កើតតារាងប្រភេទផងដែរ ហើយបម្លែងឈ្មោះប្រភេទជាលេខតែម្ដងក្នុងតារាង។ នេះមិនមែនជាគំនិតល្អសម្រាប់រេហ្គ្រេស្យុងរេហ្គ្រេស្យុង linear ទេ ព្រោះវាប្រើតម្លៃលេខនោះដើម្បីបន្ថែមលទ្ធផល បូកនឹងគុក័ភីស្យង់ផ្សេងៗ ហើយទំនាក់ទំនងរវាងលេខនិងតម្លៃថ្លៃមិនមែន linear ទេ ទោះបីបញ្ជាក់ថាលេខជាតម្លៃលំដាប់ក្រោមក៏ដោយ។
* **One-hot encoding** នឹងបម្លែងជួរឈរ `Variety` ទៅជាជួរឈរបួនគ្នា សម្រាប់ប្រភេទនីមួយៗគ្នា។ វាអាចមានតម្លៃ `1` ប្រសិនបើជួរដេកទាំងនោះនៅក្នុងប្រភេទនោះ ហើយ`0` នៅក្នុងករណីផ្សេងទៀត។ នេះមានន័យថានឹងមានគុក័ភីស្យង់បួនសម្រាប់រេហ្គ្រេស្យុង linear សម្រាប់ប្រភេទទំពាំងបាយជូ បំពេញដំបូងនៃតម្លៃថ្លៃឬ "តម្លៃបន្ថែម" សម្រាប់ប្រភេទនោះ។
កូដខាងក្រោមបង្ហាញពីរបៀបដែលយើងអាចកូដ one-hot encoding ចំពោះប្រភេទបាន៖
```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
ដើម្បីបណ្ដុះបណ្ដាលរេហ្គ្រេស្យុង linear ប្រើប្រភេទ ខណៈដែលត្រូវបានបកប្រែជា one-hot encoded ក្នុងការបញ្ចូល យើងត្រូវ initialize ទិន្នន័យ `X` និង `y` ឲ្យបានត្រឹមត្រូវ៖
```python
X = pd.get_dummies(new_pumpkins['Variety'])
y = new_pumpkins['Price']
```
កូដនៅសល់មានដូចដែលយើងបានប្រើទៅមុនសម្រាប់បណ្ដុះបណ្ដាល Linear Regression។ ប្រសិនបើអ្នកសាកល្បង វាអាចឃើញថា mean squared error ប្រហែលដូចគ្នា ប៉ុន្តែយើងទទួលបាន coefficient of determination ខ្ពស់ជាងគេ (~77%)។ ដើម្បីទទួលបានការទាយល្អប្រសើរជាងនេះ អ្នកអាចយកលក្ខណៈពិសេសពហុ (categorical) និង លក្ខណៈពិសេសចំនួន (numeric) ដូចជា `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!
## រួមបញ្ចូលគ្នាទាំងអស់
ដើម្បីបង្កើតម៉ូដែលល្អបំផុត យើងអាចប្រើទិន្នន័យផ្សំប្រភេទ (one-hot encoded categorical) និងចំនួន (numeric) ពីឧទាហរណ៍ខាងលើជាមួយរេហ្គ្រេស្យុងផូលីណូម្យ얼។ ខាងក្រោមជាកូដពេញលេញសម្រាប់សម្រួលរបស់អ្នក៖
```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)
```
នេះគួរតែផ្តល់ coefficient of determination ល្អបំផុតប្រហែល 97% ហើយ MSE=2.23 (~8% កំហុសទាយ)។
| ម៉ូដែល | MSE | ការកំណត់ត្រា |
|-------|-----|---------------|
| `DayOfYear` Linear | 2.77 (17.2%) | 0.07 |
| `DayOfYear` Polynomial | 2.73 (17.0%) | 0.08 |
| `Variety` Linear | 5.24 (19.7%) | 0.77 |
| លក្ខណៈទាំងអស់ Linear | 2.84 (10.5%) | 0.94 |
| លក្ខណៈទាំងអស់ Polynomial | 2.23 (8.25%) | 0.97 |
🏆 ល្អណាស់! អ្នកបានបង្កើតម៉ូដែលរេហ្គ្រេស្យុងបួនលក្ខណៈក្នុងមួយមេរៀន ហើយបង្កើនគុណភាពម៉ូដែលដល់ 97%។ នៅផ្នែកចុងក្រោយអំពីរេហ្គ្រេស្យុង អ្នកនឹងរៀនអំពី Logistic Regression ដើម្បីកំណត់ប្រភេទ។
---
## 🚀ការប្រកួតប្រជែង
សាកល្បងអថេរផ្សេងៗគ្នាច្រើនក្នុងកំណត់ត្រានេះ ដើម្បីមើលថាតើភាពស៊ីជម្រៅនៃទំនាក់ទំនងឆ្លើយតបដូចម្តេចទៅដោយភាពត្រឹមត្រូវរបស់ម៉ូដែល។
## [ប្រលងបន្ទាប់ម៉ោងបង្រៀន](https://ff-quizzes.netlify.app/en/ml/)
## ការត្រួតពិនិត្យ និង សិក្សាឯករាជ្យ
ក្នុងមេរៀននេះ យើងបានរៀនអំពី Linear Regression។ មានប្រភេទរេហ្គ្រេស្យុងសំខាន់ៗផ្សេងទៀត។ សូមអានអំពី Stepwise, Ridge, Lasso និង Elasticnet។ មេរៀនល្អមួយសម្រាប់សិក្សាបន្ថែមគឺ [មេរៀនស្ថិតិ ស្ទេនហ្វ័រដ៍](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning)
## បេសកកម្ម
[បង្កើតម៉ូដែល](assignment.md)
---
**ការបដិសេធ**៖
ឯកសារនេះត្រូវបានបកប្រែដោយប្រើសេវាកម្មបកប្រែ AI [Co-op Translator](https://github.com/Azure/co-op-translator)។ ខណៈពេលដែលយើងខិតខំប្រឹងប្រែងឱ្យមានភាពត្រឹមត្រូវ សូមយល់ដឹងថាការបកប្រែដោយស្វ័យប្រវត្តិអាចមានកំហុសឬភាពមិនត្រឹមត្រូវ។ ឯកសារដើមក្នុងភាសាដើមគួរត្រូវបានគិតថាជាដើមប្រភពដែលមានអំណាច។ សម្រាប់ព័ត៌មានសំខាន់ៗ គ្រាន់តែផ្តល់អនុសាសន៍ឱ្យប្រើការបកប្រែដោយមនុស្សជំនាញវិជ្ជាជីវៈ។ យើងមិនទទួលខុសត្រូវចំពោះការយល់ច្រឡំឬការបកស្រាយខុសពីការប្រើប្រាស់ការបកប្រែនេះឡើយ។