@ -1,96 +1,96 @@
# សាងសង់ម៉ូដែលរេសគ្រីស្យុងដោយប្រើ Scikit-learn: រេសគ្រីស្យុង ជាចំនួនបួនវិធី
# បង្កើតម៉ូដែលកំណត់ត្រា regression ប្រើប្រាស់ Scikit-learn: regression ៤ របៀប
## អសាមញ្ញករ Note
## សម្គាល់សម្រាប់អ្នកចាប់ផ្ដើម
រេសគ្រីស្យុងបន្ទាត់ត្រូវបានប្រើនៅពេលដែលយើងចង់ទាយទិន្នន័យ ** តម្លៃលេខ** (ឧទាហរណ៍ តម្លៃផ្ទះ សីតុណ្ហភាព ឬការលក់)។ វាដំណើរការដោយស្វែងរកបន្ទាត់ស្របមួយ ដែលតំណាងល្អបំផុតសម្រាប់ទំនាក់ទំនងរវាងមុខងារបញ្ចូល និងចេញ ។
ការកំណត់ត្រា Linear regression ត្រូវបានប្រើពេលយើងចង់ទាយទោល ** តម្លៃជាលេខ** (ឧទាហរណ៍, តម្លៃផ្ទះ, សីតុណ្ហភាព, ឬការលក់)។ វាធ្វើការដោយស្វែងរកខ្សែស្របមួយដែលតំណាងឱ្យទំនាក់ទំនងរវាងលក្ខណៈបញ្ចូល និងលទ្ធផលបានល្អបំផុត ។
ក្នុងមេរៀននេះ យើងផ្តោតសំខាន់ លើការយល់ដឹងពីគំនិតមុនពេលស្វែងយល់បន្ថែមពីបច្ចេកទេសរេសគ្រីស្យុងខ្ពស់ ជាងនេះ។
នៅ ក្នុងមេរៀននេះ យើងផ្តោតលើការយល់ដឹងពីគំនិតមុនពេលស្វែងយល់បច្ចេកទេស regression ដែលមានភាពស្មុគស្មាញ ជាងនេះ។
> គំនូរទាក់ទ ងដោយ [Dasani Madipalli ](https://twitter.com/dasani_decoded )
## [គន្លងប្រលងមុន មេរៀន](https://ff-quizzes.netlify.app/en/ml/ )
> រូបតំណា ងដោយ [Dasani Madipalli ](https://twitter.com/dasani_decoded )
## [តេស្តមុខមាត់ មេរៀន](https://ff-quizzes.netlify.app/en/ml/ )
> ### [មេរៀននេះមាន នៅក្នុងភាសា R ផង !](../../../../2-Regression/3-Linear/solution/R/lesson_3.html )
### ការណែនាំ
> ### [មេរៀននេះមាន ជាភាសា R ផងដែរ !](../../../../2-Regression/3-Linear/solution/R/lesson_3.html )
### ការណែនាំ
រហូតមកដល់បច្ចុប្បន្ន អ្នកបានស្វែងយល់ពីអ្វីដែលរេសគ្រីស្យុងជាមួយទិន្នន័យគំរូដែលបានប្រមូលពីឃ្លាំងតម្លៃគ្រប់របស់ផ្កាយប័ន្តដែលយើងនឹងប្រើពេញមួយមេរៀននេះ។ អ្នកក៏បានបង្ហាញវាជាមួយ Matplotlib ។
រហូតដល់ពេលនេះ អ្នកបានស្វែងយល់អំពីអ្វីទៅជាកំណត់ត្រា regression ជាមួយទិន្នន័យគំរូពី dataset តម្លៃផ្លែគុជ ដែលយើងនឹងប្រើកន្លងមកក្នុងមេរៀននេះ។ អ្នកក៏បានបង្ហាញវាដោយប្រើ Matplotlib ផងដែរ ។
ឥឡូវនេះ អ្នកបានត្រៀមខ្លួនដើម្បីរំដោះចូលលើរេសគ្រីស្យុងសម្រាប់ ML។ ដំណើរការបង្ហាញភាពនេះអនុញ្ញាតឱ្យអ្នកចេះយល់ពីទិន្នន័យ ប៉ុន្តែអំណាចពិតនៃប្រព័ន្ធរៀនម៉ាស៊ីនមកពី _ការបណ្តុះម៉ូដែល_ ។ ម៉ូដែលត្រូវបានបណ្តុះលើទិន្នន័យប្រវត្តិសាស្ត្រដើម្បីទទួលយកទំនាក់ទំនងទិន្នន័យដោយស្វ័យប្រវត្តិ ហើយវាអនុញ្ញាតឱ្យអ្នកទាយបានលទ្ធផលសម្រាប់ទិន្នន័យថ្មីដែលម៉ូដែលមិនបាន ឃើញពីមុន។
ឥឡូវនេះ អ្នករួចរាល់ក្នុងការចូលដល់ regression ជ្រាលជ្រៅសម្រាប់ ML។ ខណៈពេលការបង្ហាញអនុញ្ញាតឲ្យអ្នកយល់ដឹងទិន្នន័យ កម្លាំងពិតរបស់ Machine Learning មកពី _ការ ។ ម៉ូដែលទាំងនេះត្រូវបានបណ្តុះបណ្តាលលើទិន្នន័យប្រវត្តិ ដើម្បីចាប់យកក្បួនពាក់ព័ន្ធរវាងទិន្នន័យបានដោយស្វ័យប្រវត្តិ ហើយវាអនុញ្ញាតឲ្យអ្នកទាយទ្ឋានលទ្ធផលសម្រាប់ទិន្នន័យថ្មី ដែលម៉ូដែលមិនទាន់ ឃើញពីមុន។
នៅក្នុងមេរៀននេះ អ្នកនឹងរៀនបន្ថែមអំពីប្រភេទរេសគ្រីស្យុងពីរប្រភេទ: _រេសគ្រីស្យុងបន្ទាត់មូលដ្ឋាន_ និង _រេសគ្រីស្យុងព៉ូលីណូមៀល_ ជាមួយនឹងគណិតវិទ្យាខ្លះៗដែលនៅក្រោមបច្ចេកទេសទាំងនេះ។ ម៉ូដែលទាំងនោះនឹងអនុញ្ញាតឲ្យយើងទាយតម្លៃផ្កាយប័ន្តអាស្រ័យលើទិន្នន័យបញ្ចូលខុសៗ គ្នា។
នៅក្នុងមេរៀននេះ អ្នកនឹងស្វែងយល់បន្ថែមពីប្រភេទនៃ regression ២ ប្រភេទ ៖ _linear regression ជាមូលដ្ឋាន_ និង _polynomial regression_ , រួមជាមួយគណិតវិទ្យាមួយចំនួននៅពីក្រោយបច្ចេកទេសទាំងនេះ។ ម៉ូដែលទាំងនេះនឹងអនុញ្ញាតឲ្យយើងទាយតម្លៃផ្លែគុជដោយផ្អែកលើទិន្នន័យបញ្ចូលដ៏ខុស គ្នា។
[](https://youtu.be/CRxFT8oTDMg "ML for beginners - Understanding Linear Regression")
> 🎥 ចុចលើ រូបភាពខាងលើសម្រាប់វីដេអូសង្ខេបអំពីរេសគ្រីស្យុងបន្ទាត់ ។
> 🎥 ចុចរូបភាពខាងលើសម្រាប់មើលវីដេអូសង្ខេបពី linear regression ។
> ក្នុងអំឡុងពេលសិក្សាជំនាញនេះ យើងគិតថា ពុំទាមទារជំនាញគណិតវិទ្យាច្រើននោះទេ ហើយផ្តោតធ្វើឲ្យវាអាចចូលដល់បានសម្រាប់និស្សិតដែលមកពីដែនផ្សេងៗ ដូច្នេះសូមកត់សម្គាល់កំណត់ចំណាំ 🧮 ការហៅចេញ សៀវភៅរៀន និងឧបករណ៍សិក្សាផ្សេងៗ ដើម្បីជួយបង្រៀនយល់បានល្អ ។
> ក្នុងកម្រិតសិក្សាទាំងនេះ យើងសន្មតថាជំនាញគណិតវិទ្យាមិនខ្ពស់ ព្រមទាំងព្យាយាមធ្វើឲ្យវាអាចចូលដល់បានសម្រាប់សិស្សពីវិស័យផ្សេងៗ ដូច្នេះសូមមើលកំណត់សម្គាល់, 🧮 ការហៅ, រូបតំណាង និងឧបករណ៍រៀនផ្សេងទៀតសម្រាប់ជំនួយក្នុងការយល់ដឹង ។
### គួរដឹងជា មុន
### តម្រូវការ មុន
អ្នកគួរតែស្គាល់រចនាសម្ព័ន្ធទិន្នន័យផ្កាយដែលយើងកំពុងពិនិត្យឥឡូវនេះ។ អ្នកអាចស្រាវជ្រាវវា ដែលបានរៀបចំរួចទៅហើយក្នុងឯកសារ _notebook.ipynb_ នៃមេរៀននេះ។ នៅក្នុងឯកសារ តម្លៃផ្កាយបង្ហាញចេញជាតម្លៃមួយទៅក្នុងឈុតទិន្នន័យថ្មី។ សូមប្រាកដថាអ្នកអាចរត់ឯកសារនេះនៅក្នុងកណ្តុរប្រតិបត្តិការ Visual Studio Code។
អ្នកគួរតែលេខពេញចិត្តទៅនឹងរចនាសម្ព័ន្ធទិន្នន័យផ្លែគុជដែលយើងកំពុងពិនិត្យ។ អ្នកអាចរកឃើញវាត្រូវបានបញ្ចូលរួច និងបានបើកស្អាតក្នុងឯកសារ _notebook.ipynb_ របស់មេរៀននេះ។ ក្នុងឯកសារ តម្លៃផ្លែគុជត្រូវបានបង្ហាញជាតម្លៃភាគតំណាងមួយក្នុង DataFrame ថ្មី។ សូមប្រាកដថាអ្នកអាចរត់ notebooks ទាំងនេះនៅក្នុង kernel នៃ Visual Studio Code។
### ការប្រៀបប្រដៅ
### ការរៀបចំ
ជាថ្មីវិញ អ្នកកំពុងផ្ទុកទិន្នន័យនេះដើម្បីសួរចម្ងល់ ពីវា។
ដើម្បីរំលឹក អ្នកកំពុងផ្ទុកទិន្នន័យនេះដើម្បីសួរចំលើយ ពីវា។
- ពេលណាជាពេលល្អបំផុតក្នុងការជាវផ្កាយ?
- តម្លៃដែលខ្ញុំអាចរំពឹងទុកសម្រាប់ប្រអប់ផ្កាយតូចតាចនេះ?
- តើខ្ញុំគួរជាវវាទុកក្នុងធុងបាក់សែលកន្លះឬក្នុងប្រអប់ 1 1/9 បាសែលទេ ?
តោះបន្តស្គាល់ ទិន្នន័យនេះ។
- ពេលណាជាពេលល្អបំផុតក្នុងការទិញផ្លែគុជ?
- តម្លៃដែលខ្ញុំអាចរំពឹងទុក្ខប្រអប់ផ្លែគុជតូចមួយជាអ្វី?
- តើខ្ញុំគួរទិញវានៅក្នុងធុងកន្លែងកន្លះបាសែល ឬប្រអប់ ១ ១/៩ បាសែល ?
យើងសូមបន្តស្រាវជ្រាវក្នុង ទិន្នន័យនេះ។
ក្នុងមេរៀនមុន អ្នកបានបង្កើត DataFrame Pandas ហើយបំពេញវា ជាមួយផ្នែកមួយនៃទិន្នន័យដើម ដោយស្ដង់ដារតម្លៃតាមបាសែល។ ប៉ុន្តែតែតិច អ្នកបានប្រមូលបានប្រហែល ៤០០ចំនួនទិន្នន័យ ហើយ សម្រាប់ខែរដូវស្លឹកឈើជ្រុះតែប៉ុណ្ណោះ។
ក្នុងមេរៀនមុន អ្នកបានបង្កើត DataFrame របស់ Pandas ហើយបញ្ចូលវាជាមួយផ្នែកមួយនៃ dataset ដើម បម្រែបម្រួលតម្លៃដោយបាសែល។ ប៉ុន្តែដោយធ្វើការនេះ អ្នកអាចទទួលបានតែប្រហែល៤០០ចំណុចទិន្នន័យ និង សម្រាប់ខែរដូវស្លឹកឈើជ្រុះតែប៉ុណ្ណោះ។
សូមមើលទិន្នន័យដែលបានបញ្ចូលរួចនៅក្នុងទំព័រនេះក្នុងឯកសារ notebook នៃមេរៀន។ ទិន្នន័យបានបញ្ចូលរួច និងបង្ហាញរាងចំណុចព្រាត់ដើម្បីបង្ហាញខែ ទំនងជាយើងអាចរកបានព័ត៌មានលម្អិតបន្ថែមអំពីធម្មជាតិទិន្នន័យ ដោយសម្រួល វាបន្ថែមទៀត។
សូមមើលទៅទិន្នន័យដែលយើងបានបញ្ចូលរួចក្នុង notebook រួមជាមួយមេរៀននេះ។ ទិន្នន័យបានបញ្ចូលរួចហើយ និងមានការ scatterplot ដំបូងបង្ហាញតាមខែ។ ប្រហែលជាយើងអាចទទួលបានព័ត៌មានលម្អិតមួយចំនួនពីធម្មជាតិនៃទិន្នន័យដោយការសម្អាត វាបន្ថែមទៀត។
## បន្ទាត់រេសគ្រីស្យុងបន្ទាត់មួយ
## ខ្សែ regression ស្រប
ដូចដែលអ្នកបានរៀនក្នុងមេរៀន ១ គោលគំនិតនៃលំហាត់រេសគ្រីស្យុងបន្ទាត់គឺដើម្បីអាចគូរបន្ទាត់មួយសម្រាប់ ៖
ដូចដែលអ្នកបានរៀនក្នុងមេរៀនទី ១ គោលដៅនៃលំហាត់ linear regression គឺដើម្បីអាចគូសខ្សែដូចខាងក្រោម ៖
- ** បង្ហាញទំនាក់ទំនងអថេរ**។ បង្ហាញទំនាក់ទំនងរវាងអថេរ
- ** ធ្វើការទាយតម្លៃ**។ ទាយតម្លៃបានត្រឹមត្រូវថាចំណុចថ្មីនឹងស្ថិតនៅឯសន្លឹកណា ។
- ** ធ្វើការទាយទោល**។ ធ្វើការទាយទោលបានត្រឹមត្រូវលើទីតាំងនៃចំណុចទិន្នន័យថ្មីមួយ ទាក់ទងទៅខ្សែស្របនោះ ។
វាជារឿងទូទៅនៃ **Least-Squares Regression** ដើម្បីគូរបែបនេះ។ ពាក្យ "Least-Squares" មានន័យថាផលបិទកំហុសរួមមិនធំ។ សម្រាប់ចំណុចទិន្នន័យមួយៗ យើងវាស់រយៈកន្លះកោងចុះ (ហៅថា residual) រវាងចំណុចពិត និងបន្ទាត់រេសគ្រីស្យុង ។
វាមានទំាងជាគន្លងនៃ **Least-Squares Regression** ដើម្បីគូសខ្សែបែបនេះ។ ពាក្យ "Least-Squares" មានន័យថា ជំហាននៃការកាត់បន្ថយកំហុសសរុបនៅក្នុងម៉ូដែល។ សម្រាប់ចំណុចទិន្នន័យរាល់ចំណុច យើងវាស់ចម្ងាយបញ្ឈរ (ហៅថា residual) រវាងចំណុចពិត និងខ្សែ regression ។
យើងធ្វើការការ៉េរយៈចន្លោះទាំងនេះដោយមានមូលហេតុសំខាន់ពីរគឺ:
យើងធ្វើការលោតបន្ធោងចម្ងាយនេះសម្រាប់មូលហេតុសំខាន់ ២៖
1. ** ទំហំលើទិសដៅ:** យើងចង់ពិនិត្យកំហុស -5 ដូចគ្នានឹងកំហុស +5។ ការ<E19EB6> square បំរេ所有តម្លៃជាផ្កាយវិជ្ជមានទាំងអស់។
1. ** ទំហំជាងទិសដៅ៖** យើងចង់ចាត់ទុកកំហុស -៥ ដូចគ្នានឹងកំហុស +៥។ ការលោតបន្ធោងធ្វើឲ្យតម្លៃទាំងអស់ទៅជាអវិជ្ជមាន។
2. ** ពិនិត្យចំពោះចំណុចក្រៅ:** ការ square ផ្តល់តុល្យភាពលើកំហុសធំៗ បង្ខំឲ្យបន្ទាត់ នៅជិតចំណុចដែលឆ្ងាយ។
2. ** ដាក់ពិន័យចំពោះចំណុចខុសប្លែក៖** ការលោតបន្ធោងធ្វើឲ្យកំហុសធំហើយមានទំងន់បន្ថែម ហើយជំរុញឲ្យខ្សែស្រប នៅជិតចំណុចដែលឆ្ងាយ។
យើងបន្ថែមតម្លៃការ square ទាំងនេះគ្នាទៅវិញ។ គោលបំណងគឺរកបន្ទាត់ដែលសរុបនេះតិចបំផុត (តម្លៃតិចបំផុត) ហេតុនេះហៅពីរការនេះថា "Least-Squares"។
ក្រោយមក យើងនឹងបូករួមតម្លៃលោតបន្ធោងទាំងអស់ទាំងនេះ។គោលដៅរបស់យើងគឺរកឃើញខ្សែនូវកន្លែងដែលសរុបចុងក្រោយកើតមានតិចបំផុត (តម្លៃតិចបំផុតដែលអាចមាន)—អាស្រ័យពីឈ្មោះ "Least-Squares"។
> ** 🧮 បង្ហាញគណិតវិទ្យា**
> ** 🧮 បង្ហាញគណិតវិទ្យា**
>
> បន្ទាត់នេះ ដែលហៅថា _បន្ទាត់សម្រង់ល្អបំផុត _ អាចបង្ហាញដោយ [សមីការ ](https://en.wikipedia.org/wiki/Simple_linear_regression ):
> ខ្សែនេះហៅថា _line of best fit _ អាចបង្ហាញដោយ [សមីការ ](https://en.wikipedia.org/wiki/Simple_linear_regression ):
>
> ```
> Y = a + bX
> ```
>
> `X` គឺជា 'អថេរពន្យល់'។ `Y` គឺជា 'អថេរនិយម'។ ជំហាននៃបន្ទាត់គឺ `b` ហើយ `a` គឺជាចំណុចកាត់បន្ទាត់ y ដែលធ្វើអោយ `Y` រក្សាតម្លៃនៅពេល `X = 0` ។
> `X` គឺជា "អថេរពន្យល់"។ `Y` គឺជា "អថេរអាស្រ័យ"។ ចំហាយខ្សែគឺ `b` ហើយ `a` គឺជា y-intercept ដែលមានន័យថាតម្លៃ `Y` នៅពេល `X = 0` ។
>
>
>
> ជំហាន `b` គណនា ជាមួយគំនូរ [Jen Looper ](https://twitter.com/jenlooper )
> ជំហានដំបូង គណនាចំហាយ `b` ។ រូបតំណាងដោយ [Jen Looper ](https://twitter.com/jenlooper )
>
> ក្នុងពាក្យផ្សេងៗ ហើយយោងទៅលើសំណួរដើមរបស់ទិន្នន័យផ្លែគុជ៖ "ទាយតម្លៃផ្លែគុជតាមបាសែលក្នុងមួយខែ", `X` នឹងបញ្ចេញតម្លៃតម្លៃ និង `Y` នឹងបញ្ចេញខែការលក់។
>
> នៅក្នុងពាក្យផ្សេង ហើយយោងទៅតាមសំណួរដើមរបស់ទិន្នន័យផ្កាយ "ទាយតម្លៃផ្កាយតាមបាសែលដោយខែ" ការបញ្ចូល `X` នឹងយោងទៅតម្លៃ និង `Y` នឹងយោងទៅខែ។
>
>
> គណនាតម្លៃ Y។ ប្រសិនបើអ្នកបង់ប្រហែល $៤ វាចាំបាច់ត្រូវ April! គំនូរ ដោយ [Jen Looper ](https://twitter.com/jenlooper )
> គណនាតម្លៃ Y។ បើអ្នកកំពុងបង់ប្រាក់ប្រហែល $4 វាគួរតែជាខែមេសា! រូបតំណាង ដោយ [Jen Looper ](https://twitter.com/jenlooper )
>
> គណិតវិទ្យាដែលគណនាបន្ទាត់គួរតែបង្ហាញពីជំហាន `b` មានផ្ទៃមួយនៃការចាប់ផ្តើមតែម្តង នៅពេ ល `X = 0` ។
> គណិតវិទ្យាដែលគណនាចំពោះខ្សែនេះត្រូវបង្ហាញចំហាយខ្សែ ហើយវាក៏អាស្រ័យលើ intercept ឬទីតាំង `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 ) ដើម្បីមើលពីរបៀបលេខប៉ះពាល់បន្ទាត់ ។
> អ្នកអាចមើលវិធីសាស្ត្រគណនាតម្លៃទាំងនេះក្រៅពី [Math is Fun ](https://www.mathsisfun.com/data/least-squares-regression.html )។ សូមទៅសំណេះសំណាល [Least-squares calculator ](https://www.mathsisfun.com/data/least-squares-calculator.html ) ដើម្បីមើលការប៉ះពាល់នៃតម្លៃចំនួនទៅលើខ្សែ ។
## សមាភាព/Correlation
## ការចងក្រង
ពាក្យមួយទៀតដែលត្រូវយល់គឺ ** អាំងឃូផេរ៉េលេសិនកូអ៊ីហ្វ៊ីស្យង** រវាងអថេរ X និង Y ។ ប្រើ scatterplot អ្នកអាចមើលឃើញកូអ៊ីហ្វីស្យងនេះបានយ៉ាងរហ័ស។ ប្លង់ជាមួយចំណុចចំរៀងក្នុងបន្ទាត់ស្អាតនោះមានសមាភាពខ្ពស់ ប៉ុន្តែប្លង់ជាមួយចំណុចចំរាយនៅគ្រប់ទីកន្លែងរវាង X និង Y មានសមាភាព ទាប។
ពាក្យមួយទៀតដែលត្រូវយល់គឺ ** អនុផលចងក្រង (Correlation Coefficient)** រវាងអថេរ X និង Y ប្រាប់។ ដោយប្រើ scatterplot អ្នកអាចឃើញអនុផលចងក្រងនេះបានរហ័ស។ ពេល scatterplot មានចំណុចកន្លងទៅតាមខ្សែស្រប មានអនុផលចងក្រងខ្ពស់ ប៉ុន្តែពេល scatterplot មានចំណុចចែកចាយជុំវិញលើទីលានសរុប មានអនុផលចងក្រង ទាប។
ម៉ូដែលរេសគ្រីស្យុងបន្ទាត់ល្អនឹងជាៈ ម៉ូដែលដែលមានកូអ៊ីហ្វីស្យង់សមាភាពខ្ពស់ (ជិត ១ ជាង ០) ប្រើវិធី Least-Squares Regression ជាមួយបន្ទាត់រេសគ្រីស្យុង ។
ម៉ូដែល linear regression ដែលល្អ គឺម៉ូដែលមានអនុផលចងក្រងខ្ពស់ (ជិត 1 មិនមែន 0) ដោយប្រើវិធី Least-Squares Regression ជាមួយខ្សែ regression ។
✅ រត់ notebook ដែលផ្ដល់ជាមួយមេរៀននេះ និងមើល scatterplot រវាង Month និង Price ។ តើទិន្នន័យដែលភ្ជាប់រវាង Month និង Price សម្រាប់ការលក់ផ្កាយមានសមាភាពខ្ពស់ ឬទាប ដោយយោងទៅតាមការបកស្រាយរបស់អ្នកពី scatterplot? តើវាប្រែប្រួលដែរឬទេ ប្រសិនបើអ្នកប្រើមាត្រដ្ឋានលម្អិតជាងនេះជំនួស `Month` ឧ. *day of the year* ( ចំនួនថ្ងៃចាប់ពីដើមឆ្នាំ)?
✅ រាជធានី notebook ដែលបញ្ជាក់មេរៀននេះ និងមើល scatterplot រវាង ខែក្រោមតម្លៃ។ តើទិន្នន័យដែលភ្ជាប់ខែក្រោមតម្លៃសម្រាប់ការលក់ផ្លែគុជមានអនុផលចងក្រងខ្ពស់ ឬទាប តាមការបកស្រាយរូបភាពរបស់អ្នក? តើវាប្រែប្រួលបើប្រើវាស់វែងលម្អិតជាងខែដូចជា *ថ្ងៃឆ្នាំ* (ជា ចំនួនថ្ងៃចាប់ពីដើមឆ្នាំ)?
នៅលើកូដខាងក្រោម យើងនឹងកត់សម្គាល់ថា យើងបានសម្អាតទិន្នន័យរួចហើយ ហើយទទួលបាន DataFrame ដែលហៅថា `new_pumpkins` ដូចក្នុងតារាង ដូចខាងក្រោម៖
ក្នុងកូដខាងក្រោមវាយើងនឹងសន្មតថាយើងបានបន្ថែមសម្អាតទិន្នន័យ ហើយទទួលបាន DataFrame ឈ្មោះ `new_pumpkins` ដូចខាងក្រោម៖
ID | Month | DayOfYear | Variety | City | Package | Low Price | High Price | Price
---|-------|-----------|---------|------|---------|-----------|------------|-------
@ -100,36 +100,36 @@ ID | Month | DayOfYear | Variety | City | Package | Low Price | High Price | Pri
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` ដោយប្រើបន្ទាត់នេះ៖
> កូដសម្រាប់សម្អាតទិន្នន័យអាចរកបាន ក្នុង [`notebook.ipynb` ](notebook.ipynb )។ យើងបានអនុវត្តជំហានសម្អាតដដែលដ ូចមេរៀនមុន ហើយបានគណនាគូបន្ទាត់ `DayOfYear` ដោយប្រើនិយមន័យខាងក្រោម៖
```python
day_of_year = pd.to_datetime(pumpkins['Date']).apply(lambda dt: (dt-datetime(dt.year,1,1)).days)
```
ឥឡូវនេះដែលអ្នកមានយល់ដឹងពីគណិតវិទ្យារបស់រេសគ្រីស្យុងបន្ទាត់ អ្នកមក បង្កើតម៉ូដែល Regression ដើម្បីមើលថាតើយើងអាចទាយបានថាតើប្រអប់ផ្កាយណាដែលមានតម្លៃផ្កាយល្អបំផុត។ អ្នកដែលដែលជាវផ្កាយសម្រាប់តំបន់លំហែកាយថ្ងៃបុណ្យអាចចង់បានព័ត៌មាននេះ ដើម្បីអាចបឹតបញ្ចូលការជាវផ្កាយសម្រាប់តំបន់នោះ ។
ឥឡូវនេះដែលអ្នកមានការយល់ដឹងក្នងគណិតវិទ្យាក្រោយ linear regression យើងសាកល្បង បង្កើតម៉ូដែល Regression ដើម្បីមើលថាតើយើងអាចទាយថាតើកញ្ចប់ផ្លែគុជណាអាចមានតម្លៃល្អបំផុត។ មនុស្សដែលទិញផ្លែគុជសម្រាប់បរិវេទបុណ្យអាចចង់បានព័ត៌មាននេះដើម្បីអាចធ្វើអោយការទិញកញ្ចប់ផ្លែគុជមានប្រសិទ្ធភាពល្អបំផុតសម្រាប់បរិវេទ ។
## ស្វែងរកសមាភាព
## ការស្វែងរកការចងក្រង
[](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/km/barchart.a833ea9194346d76.webp" width = "50%" / >
នេះបង្ហាញថាមានសមាភាពមួយ ហើយយើងអាចព្យាយាមបណ្តុះម៉ូដែលរេសគ្រីស្យុងបន្ទាត់ ដើម្បីទាយទំនាក់ទំនងរវាង `Month` និង `Price` ឬរវាង `DayOfYear` និង `Price` ។ នេះគឺជា scatter plot បង្ហាញទំនាក់ទំនងបន្ថែម:
វាសម្លឹងបង្ហាញថា គួរតែមានការចងក្រងខ្លះ ហើយយើងអាចព្យាយាមបណ្តុះម៉ូដែល linear regression ដើម្បីទាយទំនាក់ទំនងរវាង `Month` និង `Price` ឬ `DayOfYear` និង `Price` ។ នេះគឺជា scatter plot បង្ហាញទំនាក់ទំនងចុងក្រោយ៖
< img alt = "Scatter plot of Price vs. Day of Year" src = "../../../../translated_images/km/scatter-dayofyear.bc171c189c9fd553.webp" width = "50%" / >
មកមើលពី `corr` មុខងារថា មានសមាភាពម្តេច ៖
មកមើលថាតើមានការចងក្រងជាមួយ `corr` function មែនទេ ៖
```python
print(new_pumpkins['Month'].corr(new_pumpkins['Price']))
print(new_pumpkins['DayOfYear'].corr(new_pumpkins['Price']))
```
វាបង្ហាញថាសមាភាពតូចណាស់ - ប្រាំពីរយភាគរយដោយ `Month` និង -០.១៧ ដោយ `DayOfMonth` ប៉ុន្តែអាចមានទំនាក់ទំនងសំខាន់ផ្សេងទៀត។ វាហាក់ដូចជាមានក្រុមតម្លៃផ្សេងគ្នាដែលអាចទាក់ទងនឹងប្រភេទផ្កាយផ្សេងគ្នា។ ដើម្បីបញ្ជាក់ គោលដៅនេះ យើងចុះជ្រាប និងគូរផ្សេងគ្នាសម្រាប់ផ្កាយក្នុងប្រភេទតូចៗដោយបន្ទាត់ពណ៌ផ្សេងទៀត។ ដោយផ្តល់ប៉ារ៉ាម៉ែត្រ `ax` ទៅមុខងារ scatter ការគូរអាចបង្ហាញចំណុចទាំងអស់នៅលើក្រាបនេះបាន ៖
វាបង្ហាញថាការចងក្រងមានតិច (-0.15 សម្រាប់ `Month` និង -0.17 សម្រាប់ `DayOfYear` ) ប៉ុន្តែអាចមានទំនាក់ទំនងសំខាន់ផ្សេងទៀត។ វាបង្ហាញថាមានក្រុមតម្លៃផ្សេងៗដែលទាក់ទងទៅនឹងប្រភេទផ្លែគុជផ្សេងគ្នា។ ដើម្បីបញ្ជាក់សំណងនេះ សូមគូសផ្ទាំងផ្តោតលើប្រភេទផ្លែគុជដោយពណ៌ផ្សេងៗ។ ដោយផ្តល់ផារាម៉ែត្រ `ax` ទៅ `scatter` អ្នកអាចគូសចំណុចទាំងអស់នៅលើក្រាហ្វមួយដូចគ្នា ៖
```python
ax=None
@ -141,7 +141,7 @@ for i,var in enumerate(new_pumpkins['Variety'].unique()):
< img alt = "Scatter plot of Price vs. Day of Year" src = "../../../../translated_images/km/scatter-dayofyear-color.65790faefbb9d54f.webp" width = "50%" / >
ការស៊ើបអង្កេតបង្ហាញថាប្រភេទផ្កាយមានឥទ្ធិពលលើតម្លៃនៃការលក់ច្រើនជាងកាលបរិច្ឆេទលក់។ យើងអាចមើលឃើញនេះជាមួយក្រាបបារ:
ការស៊ើបអង្កេតរបស់យើងបង្ហាញថាប្រភេទផ្លែគុជមានឥទ្ធិពលច្រើនជាងលើតម្លៃសរុបជាងថ្ងៃដែលលក់។ យើងអាចឃើញវាជាមួយក្រាហ្វបារ៖
```python
new_pumpkins.groupby('Variety')['Price'].mean().plot(kind='bar')
@ -149,7 +149,7 @@ new_pumpkins.groupby('Variety')['Price'].mean().plot(kind='bar')
< img alt = "Bar graph of price vs variety" src = "../../../../translated_images/km/price-by-variety.744a2f9925d9bcb4.webp" width = "50%" / >
ចូរយើងផ្ដោតលើប្រភេទផ្កាយតែមួយបច្ចុប្បន្ននេះ 'pie type' ហើយមើលឥទ្ធិពលនៃកាលបរិច្ឆេទលើ តម្លៃ៖
សូមផ្តោតសំខាន់បច្ចុប្បន្នលើប្រភេទផ្លែគុជតែមួយគត់ 'pie type' ហើយមើលថាតើថ្ងៃមានឥទ្ធិពលដូចម្ដេចចំពោះ តម្លៃ៖
```python
pie_pumpkins = new_pumpkins[new_pumpkins['Variety']=='PIE TYPE']
@ -157,24 +157,24 @@ pie_pumpkins.plot.scatter('DayOfYear','Price')
```
< img alt = "Scatter plot of Price vs. Day of Year" src = "../../../../translated_images/km/pie-pumpkins-scatter.d14f9804a53f927e.webp" width = "50%" / >
បើយើងគណនាសមាភាព រវាង `Price` និង `DayOfYear` ដោយប្រើ `corr` អ្នកនឹងបានប្រហែល `-0.27` - មានន័យថាការបណ្តុះម៉ូដែលទាយត្រូវមានអត្ថន័យ ។
បើយើងគណនាការចងក្រង រវាង `Price` និង `DayOfYear` ដោយប្រើ `corr` function ឥឡូវនេះ អ្នកនឹងបានតម្លៃ ប្រហែល `-0.27` - មានន័យថាការបណ្តុះម៉ូដែលទាយទោលរួចហើយមានហត្ថពលន៍ ។
> មុនពេលបណ្តុះម៉ូដែលរេសគ្រីស្យុងបន្ទាត់ វាជារឿងសំខាន់ក្នុងការធ្វើអោយទិន្នន័យរបស់យើងបានស្អាត។ រេសគ្រីស្យុងបន្ទាត់មិនល្អសម្រាប់តម្លៃដែលខ្វះទេ ដូច្នេះវាមានអត្ថន័យក្នុងការដកចេញចំណុចទិន្នន័យខ្វះ ទាំងអស់៖
> មុនពេលបណ្តុះម៉ូដែល linear regression វាម៉ត់ចត់ឲ្យប្រាកដថាទិន្នន័យស្អាត។ Linear regression មិនប្រសើរនៅពេលមានតម្លៃទំនេរ ដូច្នេះវាអាចមានអត្ថប្រយោជន៍ក្នុងការបោះបង់ជាសំណុំចំលង ទាំងអស់៖
```python
pie_pumpkins.dropna(inplace=True)
pie_pumpkins.info()
```
វិធីសាស្រ្ត មួយផ្សេងទៀតគឺបំពេញតម្លៃទទេនោះជាមួយតម្លៃមធ្យមពីជួរឈរចំរៀ ង។
វិធីមួយផ្សេងទៀតគឺបំពេញតម្លៃទំនេរទាំងនោះជាមួយតម្លៃមធ្យមពីជួរឈរដែលទាក់ទ ង។
## រេសគ្រីស្យុងបន្ទាត់សាមញ្ញ
## Regression ស្រួលៗ linear
[](https://youtu.be/e4c_UP2fSjg "ML for beginners - Linear and Polynomial Regression using Scikit-learn")
> 🎥 ចុចលើ រូបភាពខាងលើសម្រាប់វីដេអូសង្ខេបអំពីរេសគ្រីស្យុងបន្ទាត់ និងព៉ូលីណូមៀល ។
> 🎥 ចុចរូបភាពខាងលើសម្រាប់មើលវីដេអូសង្ខេបពី linear និង polynomial regression ។
ដើម្បីបណ្តុះម៉ូដែលរេសគ្រីស្យុងបន្ទាត់ របស់យើង យើងនឹងប្រើបណ្ណាល័យ **Scikit-learn** ។
ដើម្បីបណ្តុះម៉ូដែល Linear Regression របស់យើង យើងនឹងប្រើបណ្ណាល័យ **Scikit-learn** ។
```python
from sklearn.linear_model import LinearRegression
@ -182,31 +182,31 @@ from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split
```
យើងចាប់ផ្តើមដោយបំបែកតម្លៃបញ្ចូល (Features) និងលទ្ធផលដែលរំពឹងទុក (Label) ទៅជា array numpy បំបែក:
យើងចាប់ផ្ដើមដោយបំបែកកម្រិតបញ្ចូល (features) និងលទ្ធផលដែលរំពឹងទុក (label) ទៅក្នុង array numpy ផ្សេងៗ៖
```python
X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1)
y = pie_pumpkins['Price']
```
> សូមចំណាំថា យើងបានធ្វើ `reshape` លើទិន្នន័យបញ្ចូល ដើម្បីឲ្យកញ្ចប់ Linear Regression យល់បានត្រឹមត្រូវ។ Linear Regression រំពឹងថានឹងទទួល array ទំហំ 2D ដែលជួរដេកនីមួយៗជាគេហ្មត់មុខងារបញ្ចូលមួយ។ ក្នុងករណីយើងមានតែមុខងារតែមួយ ដូច្នេះត្រូវការតម្រូវ array ទៅជា N× 1 ដែល N គឺជា ចំនួនទិន្នន័យ។
> សូមចំណាំថាយើងត្រូវ បានធ្វើ `reshape` លើទិន្នន័យបញ្ចូល ដើម្បីឲ្យ package Linear Regression យល់បានត្រឹមត្រូវ។ Linear Regression រងចាំ array 2D ជាកម្រិតបញ្ចូល ដែលជារៀងរាល់ជួរឈរនៃ array តំណាងថាលក្ខណៈបញ្ចូលមួយ vector។ សម្រាប់ករណីយើង មានតែបញ្ចូលមួយ ចាំបាច់ត្រូវមាន 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` វិធីសាស្រ្ត ៖
ចុងក្រោយ ការបណ្តុះណែនាំម៉ូដែល Linear Regression ពិតប្រាកដត្រូវការចំនួនកូដប៉ុន្មានជួរប៉ុណ្ណោះ។ យើងកំណត់អំពើ `LinearRegression` ហើយតភ្ជាប់វាជាមួយទិន្នន័យដោយវិធីសាស្ត្រ `fit` ៖
```python
lin_reg = LinearRegression()
lin_reg.fit(X_train,y_train)
```
វត្ថុ `LinearRegression` បន្ទាប់ពីធ្វើការ `fit` មានគ្រប់គ្រាន់នៃអនុគមន៍រាងក្រាបដែលអាចចូលដំណើរការបានដោយប្រើគុណលក្ខណៈ `.coef_` ។ ក្នុងករណីរបស់យើង មានគ្រាន់តែអនុគមន៍រាងតែមួយ ដែលគួរតែនឹងទៅជាទីប្រហែល `-0.017` ។ វាជាអត្ថន័យថា តម្លៃមានទំនងធ្លាក់ខ្សែពេលវេលាបន្តិចបន្តួច ប៉ុន្តែមិនច្រើនទេ ប្រមាណពីរចិនសសម្រាប់មួយថ្ងៃ។ យើង អាចចូលដំណើរការចំណុចកាត់នៃក្រ ាបជាមួយអ័ក្ស Y ដោយប្រើ `lin_reg.intercept_` - វានឹងនៅជិត `21` ក្នុងករណីរបស់យើង បង្ហាញពីតម្លៃនៅដើម ឆ្នាំ។
វត្ថុ `LinearRegression` បន្ទាប់ពីបានធ្វើការបណ្តុះបណ្តាល (`fit`-ting) `.coef_` ។ នៅក្នុងករណីរបស់យើង មានគោលបំណងតែមួយ ប៉ុន្តែគួរតែប្រហែលជា `-0.017` ។ នេះមានន័យថាកម្លៃតម្លៃព្រៃដូចជានឹងធ្លាក់បន្តិចបន្តួចជាមួយពេលវេលា ប៉ុន្តែមិនច្រើនពេក យ៉ាងតិចប្រហែល 2 សេន្ទក្នុងមួយថ្ងៃ។ យើងក៏ អាចចូលដំណើរការចំណុចឆ្លុះ កាត់ សមី ការ បញ្ចេញលទ្ធផល ជាមួយអ័ក្ស Y បាន ដោយ `lin_reg.intercept_` - វានឹងប្រហែលជា `21` ក្នុងករណីយើង បង្ហាញពីតម្លៃនៅដើម ឆ្នាំ។
ដើម្បីមើលថា ម៉ូឌែលរបស់យើងមានត្រឹមត្រូវប៉ុណ្ណា យើងអាចប៉ាន់ស្មានតម្លៃនៅ លើទិន្នន័យសាកល្បង ហើយបន្ទាប់មកវាស់ថាតើការព្យាករណ៍របស់យើងនៅជិតតម្លៃដែលរំពឹងទុកយ៉ាងដូចម្តេច។ វាអាចធ្វើបានដោយប្រើសន្ទស្សន៍ root mean square error (RMSE) ដែលជាគម្លាតព្រំជាមួយមធ្យមនៃចំនួនឯកតាជាដើមរវាងតម្លៃរំពឹងទុក និងតម្លៃដែលបានព្យាករណ៍ ។
ក្នុងការមើលថាតើម៉ូឌែលរបស់យើងមានភាពត្រឹមត្រូវប៉ុណ្ណា យើងអាចទាយតម្លៃ លើទិន្នន័យសាកល្បង ហើយបន្ទាប់មកវាស់ឈរភាពជិតស្និទ្ធរបស់ការទាយរបស់យើងនឹងតម្លៃដែលរំពឹងទុក។ នេះអាចធ្វើបានដោយប្រើមាត្រដ្ឋាន root mean square error (RMSE) ដែលជាចម្ងាយរបស់មធ្យមនៃភាពខុសគ្នាប្រក់គ្នាជារូបបូកមួយរវាងតម្លៃរំពឹងនិងតម្លៃទាយ ។
```python
pred = lin_reg.predict(X_test)
@ -214,37 +214,38 @@ 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}%)')
```
កំហុសរបស់យើងមានទំនងជាច្រើនជាង២ ពិន្ទុ ដែលប្រមាណជា ~17%។ មិនល្អពេកទេ។ ទាំងនេះគឺជាសន្ទស្សន៍ដាក់ទំនាក់ទំនងគុណភាពម៉ូឌែល អាចទទួលបានជា **coefficient of determination** ដូចខាងក្រោម៖
កំហុសរបស់យើងហាក់ដូចជាប្រហែល 2 ពិន្ទុ ដែលប្រហែលជាគឺ ~17%។ មិនល្អធ្វើទេ។ មាត្រដ្ឋានជួនកាលទៀតនៃគុណភាពម៉ូឌែលគឺ **coefficient of determination** ដែលអាចទទួលបាន ដូចខាងក្រោម៖
```python
score = lin_reg.score(X_train,y_train)
print('Model determination: ', score)
```
ប្រសិនបើតម្លៃគឺ 0 វាមានន័យថា ម៉ូឌែលមិនយកទិន្នន័យអោយបានជាការបញ្ចូល និងដំណើរការជា *predictor linear អាក្រក់បំផុត* ដែលជាមធ្យមតម្លៃលទ្ធផលប៉ុណ្ណោះ។ តម្លៃ 1 មានន័យថាយើងអាចព្យាករណ៍លទ្ធផលទាំងអស់បានយ៉ាងពេញលេញ។ ក្នុងករណីរបស់យើង អនុគមន៍សង្ខេបគឺជាទីប្រហែល 0.06 ដែលគឺទាបណាស់។
បើតម្លៃគឺ 0 មានន័យថា ម៉ូឌែលមិនយកទិន្នន័យបញ្ចូលចូលក្នុងការគិតឡើយ ហើយដំណើរការជា *អ្នកទាយបន្ទាត់អាក្រក់បំផុត* ដែលគ្រាន់តែជាមធ្យមនៃលទ្ធផល។ តម្លៃ 1 មានន័យថាយើងអាចទាយបានអ្វីគ្រប់យ៉ាងយ៉ាងត្រឹមត្រូវ។ ក្នុងករណីយើង គុណហានិភ័យគឺប្រហែល 0.06 ដែលច្រើនទាប។
យើងអាចគូសបង្ហាញទិន្នន័យសាកល្បងជាមួយខ្សែ regression ដើម្បីមើលឃើញថា regression ធ្វើការយ៉ាងដូចម្តេចក្នុងករណីរបស់យើងបានកាន់តែច្បាស់ ៖
យើងក៏អាចគូរបង្ហាញទិន្នន័យសាកល្បងរួមជាមួយបន្ទាត់សមីការបញ្ចេញលទ្ធផល ដើម្បីមើលថាតើសមីការបញ្ចេញលទ្ធផលដំណើរការយ៉ាងដូចម្តេច ៖
```python
plt.scatter(X_test,y_test)
plt.plot(X_test,pred)
```
< img alt = "Linear regression" src = "../../../../translated_images/km/linear-results.f7c3552c85b0ed1c.webp" width = "50%" / >
## Regression ប៉ូលីណូមី
## សមីការបញ្ចេញលទ្ធផល Polynomial Regression
ប្រភេទមួយផ្សេងទៀតនៃ Linear Regression គឺ Polynomial Regression។ ខណៈពេលពេលដែលពេលខ្លះ មានទំនាក់ទំនងបន្ទាត់រវាងអថេរណ៍ - ការរំលាយបំពងត្រូវបានវាស់ចំណុះកាន់តែធំ ទីផ្សារក៏កាន់តែល្អ - ពេលខ្លះទំនាក់ទំនងទាំងនេះមិនអាចត្រូវបានគូសបង្ហាញជាល្វែងឬបន្ទាត់តែមួយ បានទេ។
ប្រភេទមួយទៀតនៃសមីការបញ្ចេញលទ្ធផលបន្ទាត់គឺ សមីការ Polynomial Regression។ ខណៈពេលដែលខ្លះមានទំនាក់ទំនងបន្ទាត់រវាងអថេរផ្សេងៗ - ទំហំប៉ូមពេញមួយធំពីលទ្ធផលកាន់តែលើកម្លៃ យ៉ាងណាក៏ដោយ ទំនាក់ទំនងទាំងនេះមិនអាចគូរជាបន្ទាត់ផ្លាត់ ឬបន្ទាត់ត្រង់ បានទេ។
✅ សូមមើល [ឧទាហរណ៍បន្ថែម ](https://online.stat.psu.edu/stat501/lesson/9/9.8 ) ទិន្នន័យដែលអាចប្រើបាន Polynomial Regression
✅ នៅទីនេះមាន [ឧទាហរណ៍បន្ថែម ](https://online.stat.psu.edu/stat501/lesson/9/9.8 ) នៃ ទិន្នន័យដែលអាចប្រើ Polynomial Regression
មើល ម្ដងទៀតល ើទំនាក់ទំនងរវាង Date និង Price។ តើ scatterplot នេះមើលទៅដូចជាគួរត្រូវបានវិភាគតាមបន្ទាត់តែមួយទេ? តើតម្លៃនៃតម្លៃតម្លើងនឹងមានការធ្លាក់ឡើង ? ក្នុងករណីនេះ អ្នកអាចសាកល្បង polynomial regression។
សូ មមើល ទំនាក់ទំនងរវាង Date និង Price ជាទៀត។ តើ scatterplot នេះមើលទៅគួរត្រូវបានវិភាគដោយបន្ទាត់ត្រង់តែមួយ? តើតម្លៃអាចប្រែប្រួលបានទេ ? ក្នុងករណីនេះ អ្នកអាចសាកល្បងសមីការ polynomial regression។
✅ ប៉ូលីណូមីគឺជាការបង្ហាញគណិតវិទ្យាដែលអាចមានអថេរណ៍មួយឬច្រើន និងគុណលក្ខណៈ
✅ Polynomials គឺជាអប្បបរមាណ គណិតវិទ្យា ដែលប្រហែលជាមានអថេរមួយ ឬច្រើន និងគោលបំណងជាសំណុំ
Polynomial regression បង្កើតខ្សែជារបារោងក្រោងសម្រាប់ផ្គូរផ្គងទិន្នន័យប្លែកៗសម្រាប់ការព្យាករណ៍ ។ ក្នុងករណីរបស់យើង ប្រសិនបើយើង បញ្ចូលអថេរ `DayOfYear` កាយក្រិតទីពីរចូល ទិន្នន័យបញ្ចូល យើងអាចជួយឱ្យត្រូវបានផ្គូរផ្គងជាមួយខ្សែប្រមាណប៉ារ៉ាបល (parabolic curve) ដែលមានតម្លៃអប្បបរមា នៅចំណុចមួយក្នុងឆ្នាំ។
Polynomial regression បង្កើតបន្ទាត់ពោងដើម្បីផ្គួតផ្គងទិន្នន័យមិនបន្ទាត់បានល្អជាងមុន ។ ក្នុងករណីរបស់យើង ប្រសិនបើបញ្ចូលអថេរ `DayOfYear` ការប្រកួតកំណត់ក្នុងទិន្នន័យចូលទាំងមូល យើងគួរតែអាចធ្វើការបណ្តុះក្នុងទិន្នន័យជាមួយព្រីលារតិសន្ទិលក្រោមរូបមន្ត Parabolic ដែលមានអប្បបរមា នៅចំណុចមួយក្នុងឆ្នាំ។
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 ដែលបន្ថែមលក្ខណៈ polynomial មុនបណ្តុះ regression:
Scikit-learn មាន API [pipeline ](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline ) ប្រយោជន៍ក្នុងការបញ្ចូលជំហ៊ានផ្សេងៗនៃការបញ្ចូលទិន្នន័យជាមួយគ្នា។ នៃ **estimators** ។ ក្នុងករណីយើង យើងនឹងបង្កើត pipeline ដែលដំបូងបន្ថែមលក្ខណៈ polynomial ទៅម៉ូឌែល ហើយបន្ទាប់បណ្តុះ regression៖
```python
from sklearn.preprocessing import PolynomialFeatures
@ -254,61 +255,83 @@ pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
pipeline.fit(X_train,y_train)
```
ការប្រើ `PolynomialFeatures(2)` មានន័យថាយើងនឹងបញ្ចូល polynomials កំរិតទី ២ ទាំងអស់ពីទិន្នន័យបញ្ចូល។ ក្នុងករណីយើង នឹងមានតែមួយគឺគឺ `DayOfYear` < sup > 2</ sup > ប៉ុន្តែជិតជាមួយអថេរចំនួនពីរ X និង Y វានឹងបន្ថែម X< sup > 2</ sup > , XY និង Y< sup > 2</ sup > ។ យើងអាចប្រើ polynomials កំរិតខ្ពស់ជាងនេះបានផងដែរ ប្រសិនបើយើងចង់។
Pipeline អាចប្រើបានយ៉ាងដូចគ្នាទៅនឹងវត្ថុ `LinearRegression` ដើម, គឺ៖ យើងអាច `fit` pipeline ហើយបន្ទាប់មកប្រើ `predict` ដើម្បីទទួលលទ្ធផលទាយ៖
```python
pred = pipeline.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}%)')
score = pipeline.score(X_train,y_train)
print('Model determination: ', score)
```
ដើម្បីគូរបន្ទាត់ពោងស្រទាប់ម៉ាត់ អ្នកប្រើ `np.linspace` ដើម្បីបង្កើតជួរចាប់ផ្តើមតម្លៃបញ្ចូលស្មើគ្នា ជាងការគូរតាមទិន្នន័យសាកល្បងដែលមិនមានលំដាប់ (ដែលនឹងបង្កើតបន្ទាត់ zigzag):
ការប្រើប្រាស់ `PolynomialFeatures(2)` មានន័យថាយើងនឹងបញ្ចូលក polynomial ពីដំណើរការថ្នាក់ទីពីរទាំងអស់ ពីទិន្នន័យបញ្ចូល។ ក្នុងករណីរបស់យើង វានឹងមានតែ `DayOfYear` < sup > 2</ sup > ប៉ុណ្ណោះ ប៉ុន្តែសម្រាប់អថេរឈ្មោះ X និង Y ខុសគ្នា វានឹងបន្ថែម X< sup > 2</ sup > XY និង Y< sup > 2</ sup > ។ យើងអាចប្រើ polynomial ថ្នាក់ខ្ពស់ជាងនេះប្រសិនបើចង់បាន។
```python
X_range = np.linspace(X_test.min(), X_test.max(), 100).reshape(-1,1)
y_range = pipeline.predict(X_range)
Pipeline អាចប្រើដូចជាវត្ថុ `LinearRegression` ដើម គឺយើងអាច `fit` pipeline ហើយបន្ទាប់មកប្រើ `predict` ដើម្បីទទួលបានលទ្ធផល។ នេះជាក្រាផាងបង្ហាញទិន្នន័យសាកល្បង និងខ្សែប្រមាណ៖
plt.scatter(X_test, y_test)
plt.plot(X_range, y_range)
```
នេះគឺជាបន្ទាត់បង្ហាញទិន្នន័យសាកល្បង និងបន្ទាត់សន្និដ្ឋាន៖
< img alt = "Polynomial regression" src = "../../../../translated_images/km/poly-results.ee587348f0f1f60b.webp" width = "50%" / >
ដោយប្រើ Polynomial Regression យើងអាចទទួលបាន MSE ទាបបន្តិច និង coefficient determination ខ្ពស់ជាង ប៉ុន្តែមិនច្រើនខ្លាំងទេ។ យើងត្រូវយកចិត្តទុកដាក់ទៅលើលក្ខណៈផ្សេងទៀតផង!
ប្រើ Polynomial Regression អាចទទួលបានកម្លាំង RMSE ទាបជាង និងឈរភាពកំណត់ខ្ពស់ជាង ប៉ុន្តែមិនច្រើនពេក ទេ។ យើងត្រូវយកចិត្តទុកដាក់លើលក្ខណៈផ្សេងទៀត!
> អ្នកអាចសង្កេតឃើញថា តម្លៃបណ្ដូលរបស់ កំបោរភាគច្រើនបង្ហាញនៅក្បែរបុណ្យ Halloween។ តើធ្វើដូចម្តេចដើម្បីពន្យល់ពីនេះ?
> អ្នកអាចមើលឃើញថាតម្លៃបន្ទះប៉ូមគឺអប្បបរមា ខណៈពេលដែលនៅជិតបុណ្យ Halloween។ តើអ្នកអាចពន្យល់បែបណា ?
🎃 អបអរសាទរ អ្នកទើបបង្កើតម៉ូឌែលអាចជួយព្យាករណ៍តម្លៃកំបោរភាគបាយបាន។ អ្នកប្រហែលជាអាចធ្វើបែបនេះសម្រាប់ប្រភេទកំបោរទាំងអស់ ប៉ុន្តែវាអាចធ្វើឱ្យធុញនឿយ។ យើងនឹងរៀនពីរបៀបយកប្រភេទកំបោរចូលទៅក្នុងម៉ូឌែល!
🎃 អបអរសាទរ! អ្នកបានបង្កើតម៉ូឌែលដែលអាចជួយទាយតម្លៃបន្ទះប៉ូមសម្រាប់នំបុ័ង។ អ្នកប្រហែលជាអាចធ្វើឡើងវិញសម្រាប់ប្រភេទប៉ូមទាំងអស់ ប៉ុន្តែវាជារឿងធុញនឿយ។ យើងត្រូវស្យៀនការយល់ពីរបៀបយកភាពខុសគ្នាប្រភេទប៉ូមចូលក្នុងម៉ូឌែលរបស់យើង !
## លក្ខណៈប្រភេទ (Categorical Features)
## លក្ខណៈកាតេហ្គរី
នៅពិភពល្អ គួរតែមានសមត្ថភាពក្នុងការព្យាករណ៍តម្លៃសម្រាប់ប្រភេទកំបោរផ្សេងៗដោយប្រើម៉ូឌែលដូចគ្នា។ ក៏ប៉ុន្តែ បន្ទាត់ `Variety` ខុសគ្នាពីបន្ទាត់ដូចជា `Month` ពីព្រោះវាមានតម្លៃមិនមែនជាចំនួន។ បន្ទាត់ដូចនេះហៅថា **categorical** ។
នៅក្នុងពិភពដ៏ល្អបំផុត យើងចង់អាចទាយតម្លៃរបស់ប៉ូមប្រភេទផ្សេងៗ ដោយប្រើម៉ូឌែលដដែល។ ទោះយ៉ាងណា ជួរឈរដែលមានឈ្មោះ `Variety` មានភាពខុសពីជួរឈរ ដូចជា `Month` ពីព្រោះវាមានតម្លៃមិនមែនជាលេខ។ ជួរឈរ ដូចនេះហៅថា **categorical** ។
[](https://youtu.be/DYGliioIAE0 "ML for beginners - Categorical Feature Predictions with Linear Regression")
> 🎥 ចុចរូបភាពខាងលើដើម្បីមើលវីដេអូចង្អុលបង្ហាញខ្លីអំពីការប្រើលក្ខណៈ categorical ។
> 🎥 ចុចលើរូបភាពខាងលើសម្រាប់វីដេអូសង្ខេបអំពីការប្រើលក្ខណៈកាតេហ្គរី ។
នៅទី នេះ អ្នកអាចមើលឃើញថាតម្លៃមធ្យមនៃតម្លៃអាស្រ័យ លើប្រភេទ៖
នេះអ្នកអាចមើលឃើញថាតម្លៃមធ្យមពឹងផ្អែក លើប្រភេទ៖
< img alt = "Average price by variety" src = "../../../../translated_images/km/price-by-variety.744a2f9925d9bcb4.webp" width = "50%" / >
ដើម្បីយកប្រភេទគិតចូល ជាអង្គភាពចំនួន យើងត្រូវកំណត់វាទៅជាទ្រង់ទ្រាយចំនួនឬ **encode** វា។ មានវិធីខ្លះៗដូចនេះ ៖
ដើម្បីយកប្រភេទចូលក្នុងការគិតយើងត្រូវបំលែងវាទៅជាទម្រង់លេខ ឬ **encode** វា។ មានវិធីជាច្រើនដែលអាចធ្វើបាន ៖
* **numeric encoding** ងាយស្រួលបង្កើតតារាងប្រភេទផ្សេងៗ ហើយប្តូរឈ្មោះប្រភេទជាទីតាំងក្នុងតារាង។ នេះមិនល្អសម្រាប់ linear regression ព្រោះ linear regression ប្រើតម្លៃចំនួនជាក់លាក់របស់ index ហើយបូកលទ្ធផលដោយគុណនឹង coefficient មួយ។ នៅក្នុងករណីរបស់យើង ទំនាក់ទំនងរវាងលេខរៀងនិងតម្លៃមិនមែនជាបន្ទាត់ទេ ទោះបីយើងតម្រៀបតាមលំដាប់ជាការពិត
* **One-hot encoding** ជំនួបបន្ទាត់ `Variety` ជាមួយបន្ទាត់ ៤ ប្រភេទផ្សេងៗ បន្ទាត់មួយសម្រាប់ប្រភេទនីមួយៗ។ រាល់បន្ទាត់ នឹងមាន `1` ប្រសិនបើជាបន្ទាត់នៃប្រភេទនោះ និង `0` ប្រសិនបើមិនមែន។ នោះមានន័យថា មានគុណលក្ខណៈបួននៅក្នុង linear regression សម្រាប់ប្រភេទកំបោរផ្សេងៗ ដែលរួមបញ្ចូលតម្លៃចាប់ផ្តើម (ឬតម្លៃបន្ថែម) សម្រាប់ប្រភេទនោះ
* ការបំលែងលេខសាមញ្ញ (**numeric encoding**) នឹងបង្កើតតារាងនៃប្រភេទផ្សេងៗ ហើយបន្ទាប់មកប្តូរឈ្មោះប្រភេទជាកន្លែងក្នុងតារាង។ វាមិនមែនជាគំនិតល្អសម្រាប់សមីការបញ្ចេញលទ្ធផលបន្ទាត់ ទេ ព្រោះសមីការបញ្ចេញលទ្ធផលបន្ទាត់យកតម្លៃលេខនៃសន្ទស្សន៍ចូលរួមក្នុងការគណនា ហើយបូកបន្ថែមចូល ធ្វើការបូកគុណជាមួយគោលបំណងខ្លះ។ ក្នុងករណីយើង ទំនាក់ទំនងរវាងលេខសន្ទស្សន៍ និងតម្លៃពិតមិនបន្ទាត់ទេ ទោះបីយើងធ្វើអោយតំណាងលេខត្រូវត្រួតត្រាក្នុងលំដាប់ច្បាស់ក៏ដោយ ។
* ការបំលែងប្រភេទជា **one-hot encoding** នឹងប្តូរជួរឈរ `Variety` ទៅជាជួរឈរបួនផ្សេងៗ មួយសម្រាប់ប្រភេទនីមួយៗ។ ត្រង់ជួរឈរនីមួយនឹងមានតម្លៃ `1` ប្រសិនបើជួរដេកពាក់ព័ន្ធជាប្រភេទនោះ ហើយ `0` ផ្សេងៗគ្នា។ នេះមានន័យថានឹងមានគោលបំណងបួនក្នុងសមីការបញ្ចេញលទ្ធផលឲ្យតម្រូវតម្លៃចាប់ផ្តើម (ឬ “តម្លៃបន្ថែម”) សម្រាប់ប្រភេទប៉ូមនីមួយៗ ។
កូដខាងក្រោមបង្ហាញពីរបៀបបម្លែងប្រភេទទៅ one-hot encoding ៖
កូដខាងក្រោមបង្ហាញពីរបៀបដែលយើងអាចបំលែងប្រភេទជាទម្រង់ one-hot encoded ៖
```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 regression ជាមួយ one-hot encoded variety ជាដំណើរការបញ្ចូល បូកផ្សំពីការចាប់ផ្តើម `X` និង `y` ត្រូវបានកំណត់ ត្រឹមត្រូវ៖
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
ដើម្បីបណ្តុះសមីការបញ្ចេញលទ្ធផលបន្ទាត់ប្រើបណ្តុះប្រភេទ one-hot encoded ជា input យើងគ្រាន់តែត្រូវផ្តល់ `X` និង `y` ដោយ ត្រឹមត្រូវ៖
```python
X = pd.get_dummies(new_pumpkins['Variety'])
y = new_pumpkins['Price']
```
កូដដែលនៅសល់ដូចគ្នានឹងវាដែលបាន ប្រើខាងលើសម្រាប់បណ្តុះ Linear Regression។ ប្រសិនបើអ្នកសាកល្បង វានឹងបង្ហាញថា mean squared error ប្រហែលដូចគ្នា ប៉ុន្តែ coefficient determination ទទួលបានខ្ពស់ជាង (~77%)។ ដើម្បីទទួលបានការព្យាករណ៍ត្រឹមត្រូវច្រើនទៀត អ្នកអាចយកលក្ខណៈ categorical ផ្សេងៗ និងលក្ខណៈចំនួនដូចជា `Month` ឬ `DayOfYear` មកគិតរួម។ ដើម្បីទទួលបាន array លក្ខណៈធំមួយ អ្នក អាចប្រើ `join` ៖
Remaining កូដដូចគ្នានឹងអ្វីដែលយើង ប្រើខាងលើសម្រាប់បណ្តុះ Linear Regression។ ប្រសិនបើអ្នកសាកល្បង អ្នកនឹងឃើញថាកំហុសគន្លងគំនូសមធ្យមនៃ squared error ជិតតំលៃដដែល ប៉ុន្តាយើងទទួលបាន coefficient of determination ខ្ពស់ជាង (~77%)។ ដើម្បីទទួលបានការទាយខ្ពស់ជាងនេះទៀត យើងអាចយកលក្ខណៈ categorical ជាច្រើនជាមួយ លក្ខណៈលេខ ដូចជា `Month` ឬ `DayOfYear` ។ ដើម្បីធ្វើអោយជាសំណុំលក្ខណៈធំមួយ យើង អាចប្រើ `join` ៖
```python
X = pd.get_dummies(new_pumpkins['Variety']) \
@ -317,69 +340,69 @@ X = pd.get_dummies(new_pumpkins['Variety']) \
.join(pd.get_dummies(new_pumpkins['Package']))
y = new_pumpkins['Price']
```
នៅទីនេះយើងក៏យកចិត្តទុកដាក់លើ `City` និងប្រភេទ `Package` ផងដែរ ដែលផ្តល់ RMSE 2.84 (១០.៥%) និង coefficient determination 0.94!
នៅទីនេះ យើងក៏នឹងយក `City` និងប្រភេទ `Package` ទៅគិតផង ដែលផ្តល់ឱ្យយើង MSE 2.84 (10%) និង coefficient determination 0.94!
## បង្ហាប់គ្រប់យ៉ាងរួមគ្នា
## សម្រង់ទាំងអស់ជាមួយគ្នា
ដើម្បីបង្កើតម៉ូឌែលល្អបំផុត យើងអាចប្រើទិន្នន័យបញ្ចូល រួមគ្នា (categorical one-hot encoded + numeric) ពីឧទាហរណ៍ខាងលើជាមួយ Polynomial Regression។ រួចកូដពេញលេញសម្រាប់ការងាររបស់ អ្នក៖
ដើម្បីបង្កើតម៉ូឌែលល្អបំផុត យើងអាចប្រើទិន្នន័យរួម (categorical one-hot encoded + numeric) ពីឧទាហរណ៍ខាងលើ រួមជាមួយ Polynomial Regression។ នេះជាកូដពេញលេញសម្រាប់សម្រួលអ្នក៖
```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}%)')
# គណនាតម្លៃ RMSE និងកំណត់ការសំ រេច
rmse = mean_squared_error(y_test, pred, squared=False )
print(f'RMSE: {rmse:3.3} ({rmse/pred.mean( )*100:3.3}%)')
score = pipeline.score(X_train,y_train)
print('Model determination: ', score)
```
នេះគួរតែផ្តល់ឱ្យយើងនូវ coefficient determination ខ្ពស់ជាងគេប្រមាណ 97% និង MSE=2.23 (~8% កំហុសព្យាករណ៍) ។
| ម៉ូឌែល | MSE | Coefficient 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 |
| លក្ខណៈទាំងអស់ Linear | 2.84 (10.5%) | 0.94 |
នេះគួរតែផ្តល់ឲ្យយើងបាន coefficient determination ល្អបំផុតប្រហែល ៩៧% និង RMSE=2.23 (~៨% កំហុស).
| ម៉ូឌែល | RMSE | coefficient 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 |
| លក្ខណៈទាំងអស់ Linear | 2.84 (10.5%) | 0.94 |
| លក្ខណៈទាំងអស់ Polynomial | 2.23 (8.25%) | 0.97 |
🏆 តើអ្នកបានធ្វើបានល្អ! អ្នកបង្កើតម៉ូឌែល Regression បួនក្នុងមួយមេរៀន ហើយបង្កើតគុណភាពម៉ូឌែលបានទៅដល់97%។ នៅក្នុងផ្នែកចុងក្រោយ នៃមេរៀន Regression អ្នកនឹងរៀនអំពី Logistic Regression ដើម្បីកំណត់ប្រភេទ។
🏆 សូមអបអរសាទរ! អ្នកបានបង្កើតម៉ូឌែល Regression បួនប្រភេទក្នុងមេរៀនមួយ ហើយកែលម្អគុណភាពម៉ូឌែលដល់ ៩៧%។ នៅផ្នែកចុងក្រោយ នៃមេរៀន Regression អ្នកនឹងរៀនអំពី Logistic Regression ដើម្បីកំណត់ប្រភេទ។
---
## 🚀 បញ្ញើ
---
## 🚀ការប្រកួតប្រជែង
សាកល្បងអថេរផ្សេងៗគ្នាក្នុងកំណត់ត្រានេះ ដើម្បីមើលថាតើការតភ្ជាប់ទំនាក់ទំនងសមរម្យទៅប៉ុណ្ណា ជាមួយគុណភាពម៉ូឌែល ។
សាកល្បងអថេរផ្សេងៗក្នុង notebook នេះ ដើម្បីមើលថាតើធរណីមាត្រភ្ជាប់សម្រាប់ការទាយម៉ូឌែលមានភាពទាក់ទងយ៉ាងដូចម្តេច ។
## [ការប្រលងក្រោយ មេរៀន](https://ff-quizzes.netlify.app/en/ml/ )
## [សំណួរប្រឡងបន្ទាប់ មេរៀន](https://ff-quizzes.netlify.app/en/ml/ )
## សិក្សាផ្ទាល់ខ្លួន
## ការពិនិត្យឡើងវិញ និងរៀនដោយខ្លួនឯង
នៅក្នុងមេរៀននេះ យើងបានរៀនអំពី Linear Regression។ មានប្រភេទ Regression ផ្សេងទៀតដែលសំខាន់។ សូមអានអំពី Stepwise, Ridge, Lasso និង Elasticnet។ វគ្គសិក្សាល្អសម្រាប់រៀនបន្ថែមគឺ [វគ្គសិក្សារបស់ Stanford Statistical Learning ](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning )
នៅក្នុងមេរៀននេះ យើងបានរៀនអំពី Linear Regression។ មានប្រភេទសមីការបញ្ចេញលទ្ធផលសំខាន់ផ្សេងទៀត។ សូមអានអំពី Stepwise, Ridge, Lasso និង Elasticnet techniques។ មេរៀនល្អសម្រាប់អនុវត្តន៍បន្ថែមគឺ [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 )។ ខណៈពេលដែលយើងខិតខំប្រឹងប្រែងចំពោះភាពត្រឹមត្រូវ សូមយកចិត្តទុកដាក់ថាការប្រែសម្រួលដោយស្វ័យប្រវត្តិនោះអាចមានកំហុសឬការខ្វះខាតបាន ។ ឯកសារដើមក្នុងភាសាមាតុភូមិគួរត្រូវបានយកទៅពិចារណាជាតម្រូវការសំខាន់។ សម្រាប់ព័ត៌មានសំខាន់ៗ ការប្រែសម្រួល ដោយអ្នកជំនាញមនុស្សគឺត្រូវបានផ្ដល់អនុសាសន៍ ។ យើងមិនទទួលខុសត្រូវចំពោះការយល់ច្រឡំ ឬការបកប្រែខុសចាប់ ពីការប្រើប្រាស់ការប្រែសម្រួល នេះឡើយ។
**ការបដិសេធ**:
ឯកសារនេះត្រូវបានបកប្រែដោយប្រើសេវាកម្មបកប្រែ AI [Co-op Translator ](https://github.com/Azure/co-op-translator )។ ខណៈពេលដែលយើងខិតខំប្រឹងប្រែងសម្រាប់ភាពត្រឹមត្រូវ សូមយល់ឲ្យបានថាការបកប្រែដោយស្វ័យប្រវត្តិអាចមានកំហុស ឬភាពមិនត្រឹមត្រូវ ។ ឯកសារដើមក្នុងភាសាមាតុភូមិគួរត្រូវបានគេយកជាជាតំណរ ម៉ោង សម្រាប់ព័ត៌មានសំខាន់ៗ គេណែនាំឲ្យប្រើ ការបកប ្រែដោយអ្នកជំនាញ។ យើងមិនទទួលខុសត្រូវចំពោះការយល់ច្រឡំ ឬការបកស្រាយខុសកើតឡើង ពីការប្រើប្រាស់ការបកប ្រែនេះឡើយ។
<!-- CO - OP TRANSLATOR DISCLAIMER END -->
localizeflow[bot]
2 months ago