@ -1,96 +1,96 @@
# បង្កើតម៉ូឌែលផ្សារដោយប្រើ Scikit-learn: ផ្សារបួនរបៀប
# សាងសង់ម៉ូដែលរេសគ្រីស្យុងដោយប្រើ Scikit-learn: រេសគ្រីស្យុង ជាចំនួនបួនវិធី
## សម្គាល់សម្រាប់អ្នកចាប់ផ្ដើម
## អសាមញ្ញករ Note
ការផ្សាររៀបរ៉េឌីស្យុងត្រូវបានប្រើនៅពេលដែលយើងចង់ទាយទោលតម្លៃ ** ចំនួនស៊ីផ៍** (ឧទាហរណ៍ តម្លៃផ្ទះ, សីតុណ្ហភាព ឬ លក់ចេញ)។ វាដំណើរការដោយស្វែងរករបារភាពតម្រាស់មួយដែលតំណាងឲ្យទំនាក់ទំនងរវាងលក្ខណៈបញ្ចូល និងលទ្ធផលបានល្អបំផុត ។
រេសគ្រីស្យុងបន្ទាត់ត្រូវបានប្រើនៅពេលដែលយើងចង់ទាយទិន្នន័យ ** តម្លៃលេខ** (ឧទាហរណ៍ តម្លៃផ្ទះ សីតុណ្ហភាព ឬការលក់)។ វាដំណើរការដោយស្វែងរកបន្ទាត់ស្របមួយ ដែលតំណាងល្អបំផុតសម្រាប់ទំនាក់ទំនងរវាងមុខងារបញ្ចូល និងចេញ ។
នៅក្នុងមេរៀននេះយើងផ្តោតលើការយល់ដឹងពីគំនិតមុនពេលស្រាវជ្រាវបច្ចេកវិទ្យាស្រាវជ្រាវផ្សារលំដាប់ខ្ពស់បន្ថែមទៀត ។
ក្នុងមេរៀននេះ យើងផ្តោតសំខាន់លើការយល់ដឹងពីគំនិតមុនពេលស្វែងយល់បន្ថែមពីបច្ចេកទេសរេសគ្រីស្យុងខ្ពស់ជាងនេះ ។
> រូបភាពព័ត៌មាន ដោយ [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 ផងដែរ ។
រហូតមកដល់បច្ចុប្បន្ន អ្នកបានស្វែងយល់ពីអ្វីដែលរេសគ្រីស្យុងជាមួយទិន្នន័យគំរូដែលបានប្រមូលពីឃ្លាំងតម្លៃគ្រប់របស់ផ្កាយប័ន្តដែលយើងនឹងប្រើពេញមួយមេរៀននេះ។ អ្នកក៏បានបង្ហាញវាជាមួយ Matplotlib ។
ឥឡូវនេះ អ្នករួចរាល់ក្នុងការជ្រៀតចូលជ្រាលជ្រៅចំពោះផ្សាររៀបរាប់សម្រាប់ ML។ ខណៈពេលដែលការមើលឃើញឲ្យអ្នកយល់ដឹងពីទិន្នន័យ ព្រះរាជអំណាចពិតប្រាកដរបស់ការសិក្សាម៉ាស៊ីនក្នុងការមានភាពពី _ការបណ្តុះបណ្តាលម៉ូឌែល_ ។ ម៉ូឌែលត្រូវបានបណ្តុះបណ្តាលលើទិន្នន័យប្រវត្តិសាស្ត្រដើម្បីឆាប់យល់ពីការទាក់ទងរវាងទិន្នន័យ និងអនុញ្ញាតឲ្យអ្នកទាយទោលលទ្ធផលសម្រាប់ទិន្នន័យថ្មី ដែលម៉ូឌ ែលមិនបានឃើញពីមុន។
ឥឡូវនេះ អ្នកបានត្រៀមខ្លួនដើម្បីរំដោះចូលលើរេសគ្រីស្យុងសម្រាប់ ML។ ដំណើរការបង្ហាញភាពនេះអនុញ្ញាតឱ្យអ្នកចេះយល់ពីទិន្នន័យ ប៉ុន្តែអំណាចពិតនៃប្រព័ន្ធរៀនម៉ាស៊ីនមកពី _ការបណ្តុះម៉ូដែល_ ។ ម៉ូដែលត្រូវបានបណ្តុះលើទិន្នន័យប្រវត្តិសាស្ត្រដើម្បីទទួលយកទំនាក់ទំនងទិន្នន័យដោយស្វ័យប្រវត្តិ ហើយវាអនុញ្ញាតឱ្យអ្នកទាយបានលទ្ធផលសម្រាប់ទិន្នន័យថ្មីដែលម៉ូដ ែលមិនបានឃើញពីមុន។
នៅក្នុងមេរៀននេះ អ្នកនឹងរៀនបន្ថែមអំពីប្រភេទផ្សាររៀបរាប់ពីរ: _ផ្សាររៀបរាប់រាងតែមួយមូលដ្ឋាន_ និង _ផ្សាររៀបរាប់ពហុបូឡីណូម្យែល_ រួមជាមួយគណិតវិទ្យាផ្នែកខ្លះដែលគាំទ្របច្ចេកទេសទាំងនេះ។ ម៉ូឌែលទាំងនេះនឹងអនុញ្ញាតឲ្យយើងទាយតម្លៃផ្លែផ្អែខោចដោយផ្អែកលើទិន្នន័យបញ្ចូលផ្សេងៗ ។
នៅក្នុងមេរៀននេះ អ្នកនឹងរៀនបន្ថែមអំពីប្រភេទរេសគ្រីស្យុងពីរប្រភេទ: _រេសគ្រីស្យុងបន្ទាត់មូលដ្ឋាន_ និង _រេសគ្រីស្យុងព៉ូលីណូមៀល_ ជាមួយនឹងគណិតវិទ្យាខ្លះៗដែលនៅក្រោមបច្ចេកទេសទាំងនេះ។ ម៉ូដែលទាំងនោះនឹងអនុញ្ញាតឲ្យយើងទាយតម្លៃផ្កាយប័ន្តអាស្រ័យលើទិន្នន័យបញ្ចូលខុសៗគ្នា ។
[](https://youtu.be/CRxFT8oTDMg "ML for beginners - Understanding Linear Regression")
> 🎥 ចុចរូបភាពខាងលើសម្រាប់មើលវីដេអូបែបខ្លីអំពីផ្សាររៀបរាប់រាងតែ្មួយមូលដ្ឋាន ។
> 🎥 ចុចលើ រូបភាពខាងលើសម្រាប់វីដេអូសង្ខេបអំពីរេសគ្រីស្យុងបន្ទាត់ ។
> លើកទូលាយកម្មវិធីសិក្សានេះ យើងគិតថា មានចំណេះដឹងគណិតវិទ្យាតិចតួច ប៉ុន្តែទាមទារឱ្យមានភាពងាយស្រួលសម្រាប់សិស្សដែលមកពីវិស័យផ្សេងទៀត ដូច្នេះសូមប្រយ័ត្នមានកំណត់សម្គាល់ 🧮 ការហៅចេញ វិចារណាធិការប្រើស្លាកបាច់បិទ និងឧបករណ៍អប់រំផ្សេងៗសម្រាប់ជួយឲ្យយល់ ។
> ក្នុងអំឡុងពេលសិក្សាជំនាញនេះ យើងគិតថា ពុំទាមទារជំនាញគណិតវិទ្យាច្រើននោះទេ ហើយផ្តោតធ្វើឲ្យវាអាចចូលដល់បានសម្រាប់និស្សិតដែលមកពីដែនផ្សេងៗ ដូច្នេះសូមកត់សម្គាល់កំណត់ចំណាំ 🧮 ការហៅចេញ សៀវភៅរៀន និងឧបករណ៍សិក្សាផ្សេងៗ ដើម្បីជួយបង្រៀនយល់បានល្អ ។
### លក្ខណ្ឌមុនបច្ចេកទេស
### គួរដឹងជាមុន
អ្នកគួរតែស្គាល់រចនាសម្ព័ន្ធទិន្នន័យផ្លែផ្អែខោច ដែលយើងកំពុងពិនិត្យឥឡូវនេះ។ អ្នកអាចរកបានវាត្រូវបានផ្ទុករួចហើយ និងបានសម្អាតរួចក្នុងឯកសារ _notebook.ipynb_ នៃមេរៀននេះ។ ក្នុងឯកសារ គឺបង្ហាញតម្លៃផ្លែផ្អែខោចប្រចាំមួយកំប៉ិលក្នុងតារាងទិន្នន័យថ្មី។ ដូច្នេះប្រាកដថាអ្នកអាចរត់កំណត់ត្រាតំណាងទាំងនេះនៅក្នុងកណ្តុររបស់ Visual Studio Code។
អ្នកគួរតែស្គាល់រចនាសម្ព័ន្ធទិន្នន័យផ្កាយ ដែលយើងកំពុងពិនិត្យឥឡូវនេះ។ អ្នកអាចស្រាវជ្រាវវា ដែលបានរៀបចំរួចទៅហើយក្នុងឯកសារ _notebook.ipynb_ នៃមេរៀននេះ។ នៅក្នុងឯកសារ តម្លៃផ្កាយបង្ហាញចេញជាតម្លៃមួយទៅក្នុងឈុតទិន្នន័យថ្មី។ សូមប្រាកដថាអ្នកអាចរត់ឯកសារនេះនៅក្នុងកណ្តុរប្រតិបត្តិការ Visual Studio Code។
### ការរៀបចំ
### ការប្រៀបប្រដៅ
ដើម្បីរំលឹក អ្នកកំពុងផ្ទុកទិន្នន័យនេះដើម្បីសួរចំឡើយ ពីវា។
ជាថ្មីវិញ អ្នកកំពុងផ្ទុកទិន្នន័យនេះដើម្បីសួរចម្ងល់ ពីវា។
- តើ ពេលណា ទិញផ្លែផ្អែខោច?
- តើត ម្លៃអ្វី ដែលខ្ញុំអាចរំពឹងទុកចំពោះប្រអប់ផ្លែផ្អែខោចតូច?
- តើខ្ញុំគួរទិញវាក្នុងធុងក៍មួយពាក់កណ្តាលកំប៉ិល ឬដោយប្រអប់ 1 1/9 កំប៉ិល ?
អើយ! យើងសូមលត់ចូលទៅក្នុងទិន្នន័យនេះបន្ថែម ។
- ពេលណាជាពេលល្អបំផុតក្នុងការជាវផ្កាយ?
- តម្លៃដែលខ្ញុំអាចរំពឹងទុកសម្រាប់ប្រអប់ផ្កាយតូចតាចនេះ?
- តើខ្ញុំគួរជាវវាទុកក្នុងធុងបាក់សែលកន្លះឬក្នុងប្រអប់ 1 1/9 បាសែលទេ ?
តោះបន្តស្គាល់ទិន្នន័យនេះ ។
ក្នុងមេរៀនមុន អ្នកបានបង្កើតតារាងតំណាង Pandas ហើយផ្ទុកវានៅជុំវិញផ្នែកមួយនៃឯកសារដើម ដោយប្រើការតម្រឹមតម្លៃផ្ទាល់មួយកំប៉ិល។ ប៉ុន្តែបច្ចុប្បន្ននេះ អ្នកអាចប្រមូលបានត្រឹមតែប្រហែល ៤០០ចំណុចទិន្នន័យហើយត្រឹមតែ សម្រាប់ខែរដូវស្លឹកឈើជ្រុះតែប៉ុណ្ណោះ។
ក្នុងមេរៀនមុន អ្នកបានបង្កើត DataFrame Pandas ហើយបំពេញវា ជាមួយផ្នែកមួយនៃទិន្នន័យដើម ដោយស្ដង់ដារតម្លៃតាមបាសែល។ ប៉ុន្តែតែតិច អ្នកបានប្រមូលបានប្រហែល ៤០០ចំនួនទិន្នន័យ ហើយ សម្រាប់ខែរដូវស្លឹកឈើជ្រុះតែប៉ុណ្ណោះ។
មើលទិន្នន័យដែលបានផ្ទុករួចជាមុនក្នុងកំណត់ត្រារួមនៅក្នុងមេរៀននេះ។ ទិន្នន័យត្រូវបានផ្ទុករួចហើយ និងបានចុះតំណាងតាមរយៈ scatterplot ដើម្បីបង្ហាញទិន្នន័យតាមខែ។ ប្រហែលជាយើងអាចយកព័ត៌មានជាក់លាក់បន្ថែមអំពីលក្ខណៈទិន្នន័យដោយសម្អាត វាបន្ថែមទៀត។
សូម មើលទិន្នន័យដែលបានបញ្ចូលរួចនៅក្នុងទំព័រនេះក្នុងឯកសារ notebook នៃមេរៀន។ ទិន្នន័យបានបញ្ចូលរួច និងបង្ហាញរាងចំណុចព្រាត់ដើម្បីបង្ហាញខែ ទំនងជាយើងអាចរកបានព័ត៌មានលម្អិតបន្ថែមអំពីធម្មជាតិទិន្នន័យ ដោយសម្រួល វាបន្ថែមទៀត។
## សន្ទស្សន៍ផ្សាររៀបរាប់រាងតែ មួយ
## បន្ទាត់រេសគ្រីស្យុងបន្ទាត់ មួយ
ដូចដែលអ្នកបានរៀនក្នុងមេរៀន១ គោលបំណងនៃសមាហរណកម្ម Linear Regression គឺដើម្បីគូសបន្ទាត់មួយដែល:
ដូចដែលអ្នកបានរៀនក្នុងមេរៀន ១ គោលគំនិតនៃលំហាត់រេសគ្រីស្យុងបន្ទាត់គឺដើម្បីអាចគូរបន្ទាត់មួយសម្រាប់៖
- ** បង្ហាញទំនាក់ទំនងអថេរ**។ បង្ហាញទំនាក់ទំនងរវាងអថេរ
- ** ធ្វើការទាយទោល**។ ធ្វើការទាយទោលយ៉ាងត្រឹមត្រូវថាចំណុចទិន្នន័យថ្មីនឹងស្ថិតនៅកន្លែងណាជិតបន្ទាត់នោះ ។
- ** ធ្វើការទាយតម្លៃ**។ ទាយតម្លៃបានត្រឹមត្រូវថាចំណុចថ្មីនឹងស្ថិតនៅឯសន្លឹកណា ។
សិក្សារៀបរាប់ប្រើមធ្យោបាយ **Least-Squares Regression** ជាទូទៅក្នុងការគូសបន្ទាត់ប្រភេទនេះ។ ពាក្យ "Least-Squares" មានន័យពីដំណើរការកាត់បន្ថយកំហុសសរុបក្នុងម៉ូឌែលយើង។ សម្រាប់ចំណុចទិន្នន័យរាល់គឺយើងវាស់ចម្ងាយឈរ (ហៅថា residual) រវាងចំណុចពិត និងបន្ទាត់ផ្សារ។
វាជារឿងទូទៅនៃ **Least-Squares Regression** ដើម្បីគូរបែបនេះ។ ពាក្យ "Least-Squares" មានន័យថាផលបិទកំហុសរួមមិនធំ។ សម្រាប់ចំណុចទិន្នន័យមួយៗ យើងវាស់រយៈកន្លះកោងចុះ (ហៅថា residual) រវាងចំណុចពិត និងបន្ទាត់រេសគ្រីស្យុង។
យើងសម្រួលចម្ងាយទាំងនេះដល់កំរិតក្រោមពីហេតុផលពីរចម្បង៖
យើងធ្វើការការ៉េរយៈចន្លោះទាំងនេះដោយមានមូលហេតុសំខាន់ពីរគឺ:
1. ** ទំហំលើទិសដៅ**៖ យើងចង់ដាក់តម្លៃកំហុស -5 និង +5 ដូចគ្នា។ ការបង្រួចគុណបង្កើតអោយតម្លៃទាំងអស់ជាស្រប។
1. ** ទំហំលើទិសដៅ:** យើងចង់ពិនិត្យកំហុស -5 ដូចគ្នានឹងកំហុស +5។ ការ<E19EB6> square បំរេ所有តម្លៃជាផ្កាយវិជ្ជមានទាំងអស់។
2. ** ពិនិត្យសំណុំនៃចំណុចក្រៅ**៖ ការបង្រួចគុណធ្វើឲ្យកំហុសធំៗទទួលបានទំងន់ច្រើនជាង ហើយបណ្តាលឲ្យបន្ទាត់នៅជិតចំណុចចម ្ងាយ។
2. ** ពិនិត្យចំពោះចំណុចក្រៅ:** ការ square ផ្តល់តុល្យភាពលើកំហុសធំៗ បង្ខំឲ្យបន្ទាត់នៅជិតចំណុចដែលឆ ្ងាយ។
បន្ទាប់មកយើងបូកតម្លៃក្រោមគុណទាំងនេះទាំងឡាយគ្នា។ គោលដៅគឺរកបន្ទាត់ជាក់លាក់មួយដែលបូកចុងក្រោយនេះតិចជាងគេ (តម្លៃតិចបំផុត)—ហេតុនេះហៅ ថា "Least-Squares"។
យើងបន្ថែមតម្លៃការ square ទាំងនេះគ្នាទៅវិញ។ គោលបំណងគឺរកបន្ទាត់ដែលសរុបនេះតិចបំផុត (តម្លៃតិចបំផុត) ហេតុនេះហៅពីរការនេះ ថា "Least-Squares"។
> ** 🧮 បង្ហាញគណិតវិទ្យា**
> ** 🧮 បង្ហាញគណិតវិទ្យា**
>
> បន្ទាត់នេះ ដែលហៅថា _បន្ទាត់ ត្រូវគ្នា_ អាចបញ្ចេញដោយ[សមីការ]( https://en.wikipedia.org/wiki/Simple_linear_regression):
> បន្ទាត់នេះ ដែលហៅថា _បន្ទាត់ សម្រង់ល្អបំផុត_ អាចបង្ហាញដោយ [សមីការ ]( https://en.wikipedia.org/wiki/Simple_linear_regression
>
> ```
> Y = a + bX
> ```
>
> `X` គឺជា 'អថេរពន្យល់'។ `Y` គឺជា 'អថេរពឹងផ្អែក'។ លំនឹងបន្ទាត់គឺ `b` ហើយ `a` គឺ កន្លែងឆ្លងដែក y-intercept ដែលសំដៅតម្លៃ `Y` នៅពេល `X = 0` ។
> `X` គឺជា 'អថេរពន្យល់'។ `Y` គឺជា 'អថេរនិយម'។ ជំហាននៃបន្ទាត់គឺ `b` ហើយ `a` គឺជាចំណុចកាត់បន្ទាត់ y ដែលធ្វើអោយ `Y` រក្សាតម្លៃនៅពេល `X = 0` ។
>
>
>
> ជំហានដំបូង គណនាលំនឹង `b` ។ រូបភាពព័ត៌មានដោយ [Jen Looper ](https://twitter.com/jenlooper )
>
> ផ្ទុះពីនេះ និងបើសិនវាចង់បង្ហាញពីសំណួរដើមទិន្នន័យផ្លែផ្អែខោច៖ "ទាយតម្លៃផ្លែផ្អែខោចមួយក្នុងមួយកំប៉ិល តាមខែ" គឺ `X` នឹងសំដៅតម្លៃ និង `Y` នឹងសំដៅខែក្នុងការលក់។
> ជំហាន `b` គណនា ជាមួយគំនូរ [Jen Looper ](https://twitter.com/jenlooper )
>
> នៅក្នុងពាក្យផ្សេង ហើយយោងទៅតាមសំណួរដើមរបស់ទិន្នន័យផ្កាយ "ទាយតម្លៃផ្កាយតាមបាសែលដោយខែ" ការបញ្ចូល `X` នឹងយោងទៅតម្លៃ និង `Y` នឹងយោងទៅខែ។
>
>
> គណនាតម្លៃ `Y` ។ ប្រសិនបើអ្នកប្រាក់តម្លៃប្រហែល $4 វាត្រូវតែជាខែ មេសា! រូបភាពព័ត៌មានJen Looper ](https://twitter.com/jenlooper )
> គណនាតម្លៃ Y។ ប្រសិនបើអ្នកបង់ប្រហែល $៤ វាចាំបាច់ត្រូវ April! គំនូរ ដោយ [Jen Looper ](https://twitter.com/jenlooper )
>
> គណិតវិទ្យាដែលគណនាបន្ទាត់ត្រូវបង្ហាញលំនឹងបន្ទាត់ ដែលត្រូវអាស្រ័យលើការឆ្លងដែក ឬកន្លែងដែល `Y` មានតម្លៃ នៅពេល `X = 0` ។
> គណិតវិទ្យាដែលគណនាបន្ទាត់គួរតែបង្ហាញពីជំហាន `b` មានផ្ទៃមួយនៃការចាប់ផ្តើមតែម្តង នៅពេល `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 នេះ ](https://www.mathsisfun.com/data/least-squares-calculator.html ) ដើម្បីមើលពីរបៀបលេខប៉ះពា ល់បន្ទាត់។
## ទំនាក់ទំនងសមាមាត្រ (Correlation)
## សមាភាព/Correlation
ពាក្យមួយទៀតដែលត្រូវយល់គឺ ** សមាមាត្រជាគូ** រវាងអថេរ X និង Y។ អ្នកអាចមើលសមាមាត្រនេះបានយ៉ាងរហ័សតាមការគូស scatterplot។ ប្លាត់ដែលមានចំណុចរាយព្រមទ្រុងក្នុងបន្ទាត់ត្រូវមានសមាមាត្រខ្ពស់ ប៉ុន្តែប្លាត់ដែលចំណុចរាយឡើងគ្នារវាង X និង Y គឺមានសមាមាត្រតិច ។
ពាក្យមួយទៀតដែលត្រូវយល់គឺ ** អាំងឃូផេរ៉េលេសិនកូអ៊ីហ្វ៊ីស្យង** រវាងអថេរ X និង Y ។ ប្រើ scatterplot អ្នកអាចមើលឃើញកូអ៊ីហ្វីស្យងនេះបានយ៉ាងរហ័ស។ ប្លង់ជាមួយចំណុចចំរៀងក្នុងបន្ទាត់ស្អាតនោះមានសមាភាពខ្ពស់ ប៉ុន្តែប្លង់ជាមួយចំណុចចំរាយនៅគ្រប់ទីកន្លែងរវាង X និង Y មានសមាភាពទាប ។
ម៉ូឌែលផ្សារ Linear Regression ល្អគឺបានសមាមាត្រខ្ពស់ (ជិត 1 ជាង 0) ដោយប្រើវិធីសាស្រ្ត Least-Squares Regression ជាមួយបន្ទាត់ផ្សារ ។
ម៉ូដែលរេសគ្រីស្យុងបន្ទាត់ល្អនឹងជាៈ ម៉ូដែលដែលមានកូអ៊ីហ្វីស្យង់សមាភាពខ្ពស់ (ជិត ១ ជាង ០) ប្រើវិធី Least-Squares Regression ជាមួយបន្ទាត់រេសគ្រីស្យុង ។
✅ រត់កំណត់ត្រាជាមួយមេរៀននេះ រួចមើល scatterplot សមាមាត្រពី Month ទៅ Price។ តើទិន្នន័យដែលភ្ជាប់ Month ទៅ Price សម្រាប់ការលក់ផ្លែផ្អែខោច យល់ថាសមាមាត្រខ្ពស់ឬទាប តាមការពិចារណារបស់អ្នកលើ scatterplot? តើវាប្រែប្រួលប្រសិនបើអ្នកប្រើវិមាត្រចំណាស់ជាងមុន ហៅថា *ថ្ងៃនៃឆ្នាំ * (ចំនួនថ្ងៃចាប់ពីដើមឆ្នាំ)?
✅ រត់ notebook ដែលផ្ដល់ជាមួយមេរៀននេះ និងមើល scatterplot រវាង Month និង Price ។ តើទិន្នន័យដែលភ្ជាប់រវាង Month និង Price សម្រាប់ការលក់ផ្កាយមានសមាភាពខ្ពស់ ឬទាប ដោយយោងទៅតាមការបកស្រាយរបស់អ្នកពី scatterplot? តើវាប្រែប្រួលដែរឬទេ ប្រសិនបើអ្នកប្រើមាត្រដ្ឋានលម្អិតជាងនេះជំនួស `Month` ឧ. *day of the year * (ចំនួនថ្ងៃចាប់ពីដើមឆ្នាំ)?
ក្នុងកូដខាងក្រោម នឹងគិតថាអ្នកបានសម្អាតទិន្នន័យហើយ ហើយទទួលបាន data frame មានឈ្មោះ `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 ដើម្បីមើលថាតើយើងអាចទាយបានថាតើប្រអប់ផ្កាយណាដែលមានតម្លៃផ្កាយល្អបំផុត។ អ្នកដែលដែលជាវផ្កាយសម្រាប់តំបន់លំហែកាយថ្ងៃបុណ្យអាចចង់បានព័ត៌មាននេះ ដើម្បីអាចបឹតបញ្ចូលការជាវផ្កាយសម្រាប់តំបន់នោះ ។
## ការស្វែងរកទំនាក់ទំនងសមាមាត្រ
## ស្វែងរកសមាភាព
[](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%" / >
នេះបង្ហាញថាគួរតែមានទំនាក់ទំនងមួយ និងយើងអាចសាកល្បងបណ្តុះម៉ូឌែល Linear Regression ដើម្បីទាយទំនាក់ទំនងរវាង `Month` និង `Price` ឬស្របពេល `DayOfYear` និង `Price` ។ នេះជាការបង្ហាញទិន្នន័យ scatterplot មួយបង្ហាញពីទំនាក់ទំនងចុងក្រោយ៖
នេះបង្ហាញថាមានសមាភាពមួយ ហើយយើងអាចព្យាយាមបណ្តុះម៉ូដែលរេសគ្រីស្យុងបន្ទាត់ ដើម្បីទាយទំនាក់ទំនងរវាង `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` function ដែរឬ?
មកមើលពី `corr` មុខងារថា មានសមាភាពម្តេច៖
```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 អ្នកអាចគូសចំណុចទាំងអស់នៅលើតារាងតែមួយ។
វាបង្ហាញថាសមាភាពតូចណាស់ - ប្រាំពីរយភាគរយដោយ `Month` និង -០.១៧ ដោយ `DayOfMonth` ប៉ុន្តែអាចមានទំនាក់ទំនងសំខាន់ផ្សេងទៀត។ វាហាក់ដូចជាមានក្រុមតម្លៃផ្សេងគ្នាដែលអាចទាក់ទងនឹងប្រភេទផ្កាយផ្សេងគ្នា។ ដើម្បីបញ្ជាក់ គោលដៅនេះ យើងចុះជ្រាប និងគូរផ្សេងគ្នាសម្រាប់ផ្កាយក្នុងប្រភេទតូចៗដោយបន្ទាត់ពណ៌ផ្សេងទៀត។ ដោយផ្តល់ប៉ារ៉ាម៉ែត្រ `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' ហើយមើលឥទ្ធិពលនៃ កាលបរិច្ឆេទលើតម្លៃ៖
```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` អ្នកនឹងបានប្រហែល `-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** ។
ដើម្បីបណ្តុះម៉ូដែលរេសគ្រីស្យុងបន្ទាត់ របស់យើង យើងនឹងប្រើបណ្ណាល័យ **Scikit-learn** ។
```python
from sklearn.linear_model import LinearRegression
@ -182,70 +182,69 @@ 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 ទិន្នន័យបញ្ចូល ដើម្បីឲ្យ package Linear Regression យល់បានត្រឹមត្រូវ។ Linear Regression រង់ចាំ input array 2D ដែលជាតួរទំាងរបស់ជួរឈរនីមួយៗជាតួរផ្គុំឡើង ដូច្នេះសម្រាប់ input តែមួយ យើងចង់បាន array ទំហំ N× ទិន្នន័យ។
> សូមចំណាំថា យើងបានធ្វើ `reshape` លើទិន្នន័យបញ្ចូល ដើម្បីឲ្យកញ្ចប់ Linear Regression យល់បានត្រឹមត្រូវ។ Linear Regression រំពឹងថានឹងទទួល array ទំហំ 2D ដែលជួរដេកនីមួយៗជាគេហ្មត់មុខងារបញ្ចូលមួយ។ ក្នុងករណីយើងមានតែមុខងារតែមួយ ដូច្នេះត្រូវការតម្រូវ 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` ៖
ចុងក្រោយ ការបណ្តុះម៉ូដែលរេសគ្រីស្យុងបន្ទាត់ពិតត្រឹមពីរជួរដេកកូដប៉ុណ្ណោះ។ យើងកំណត់វត្ថុ `LinearRegression` ហើយបង្វួលវាទៅលើទិន្នន័យដោយប្រើ `fit` វិធីសាស្រ្ត ៖
```python
lin_reg = LinearRegression()
lin_reg.fit(X_train,y_train)
```
Object `LinearRegression` បន្ទាប់ពីបាន `fit` រួចមានគុក័ភីស្យង់ទាំងអស់នៃរេហ្គ្រេស្យុង ដែលអាចចូលប្រើបានដោយប្រើបច្ចេក `.coef_` ។ ក្នុងករណីរបស់យើង មានគុក័ភីស្យង់តែ១ ដែលគួរតែប្រហែល `-0.017` ។ វាមានន័យថា តម្លៃថ្លៃទំនិញមានន័យថាកំពុងធ្លាក់បន្តិចបន្តួចជាមួយពេលវេលា ប៉ុន្តែមិនចាញ់ខ្លាំង ត្រឹមប្រហែល ២ សេនក្នុងមួយថ្ងៃទេ។ យើងក៏អាចចូលប្រើចំណុចឆ្លងផ្តួចផ្តើមរបស់រេហ្គ្រេស្យុងជាមួយអ័ក្ស Y ដោយប្រើ `lin_reg.intercept_` ដែលនៅក្នុងករណីរបស់យើងនឹងប្រហែល `21` ដែលបង្ហាញពីតម្លៃថ្លៃលើកដំបូងនៃ ឆ្នាំ។
វត្ថុ `LinearRegression` បន្ទាប់ពីធ្វើការ `fit` មានគ្រប់គ្រាន់នៃអនុគមន៍រាងក្រាបដែលអាចចូលដំណើរការបានដោយប្រើគុណលក្ខណៈ `.coef_` ។ ក្នុងករណីរបស់យើង មានគ្រាន់តែអនុគមន៍រាងតែមួយ ដែលគួរតែនឹងទៅជាទីប្រហែល `-0.017` ។ វាជាអត្ថន័យថា តម្លៃមានទំនងធ្លាក់ខ្សែពេលវេលាបន្តិចបន្តួច ប៉ុន្តែមិនច្រើនទេ ប្រមាណពីរចិនសសម្រាប់មួយថ្ងៃ។ យើងអាចចូលដំណើរការចំណុចកាត់នៃក្រាបជាមួយអ័ក្ស Y ដោយប្រើ `lin_reg.intercept_` - វានឹងនៅជិត `21` ក្នុងករណីរបស់យើង បង្ហាញពីតម្លៃនៅដើម ឆ្នាំ។
ដើម្បីមើលថាម៉ូដែលរបស់យើងមានភាពត្រឹមត្រូវប៉ុណា យើងអាចទាយទម្លៃថ្លៃទំនិញលើប្រភេទ ទិន្នន័យសាកល្បង ហើយបន្ទាប់មកវាស់ថាតម្លៃទាយរបស់យើងជិតតម្លៃដែលរំពឹងទុកប៉ុណ្ណា។ វាអាចធ្វើបានដោយប្រើតំលៃ MSE (mean square error) ដែលជាមធ្យមនៃខុសគ្នារវាងតម្លៃរំពឹងទុក និងតម្លៃទាយដែលបានក្រោមភាពឡើងវិញ។
ដើម្បីមើលថា ម៉ូឌែលរបស់យើងមានត្រឹមត្រូវប៉ុណ្ណា យើងអាចប៉ាន់ស្មានតម្លៃនៅលើ ទិន្នន័យសាកល្បង ហើយបន្ទាប់មកវាស់ថាតើការព្យាករណ៍របស់យើងនៅជិតតម្លៃដែលរំពឹងទុកយ៉ាងដូចម្តេច។ វាអាចធ្វើបានដោយប្រើសន្ទស្សន៍ root mean square error (RMSE) ដែលជាគម្លាតព្រំជាមួយមធ្យមនៃចំនួនឯកតាជាដើមរវាងតម្លៃរំពឹងទុក និងតម្លៃដែលបានព្យាករណ៍។
```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}%)')
r mse = np.sqrt(mean_squared_error(y_test,pred))
print(f'RMSE: {rmse:3.3} ({r mse/np.mean(pred)*100:3.3}%)')
```
កំហុសរបស់យើងឆ្ងាយប្រហែល ២ ពិន្ទុ ដែលជាប្រហែល ~17%។ មិនល្អពេកទេ។ សញ្ញាមួយទៀតនៃគុណភាពម៉ូដែលគឺ **coefficient of determination** ដែលអាចទទួលបាន ដូចខាងក្រោម៖
កំហុសរបស់យើងមានទំនងជាច្រើនជាង២ ពិន្ទុ ដែលប្រមាណជា ~17%។ មិនល្អពេកទេ។ ទាំងនេះគឺជាសន្ទស្សន៍ដាក់ទំនាក់ទំនងគុណភាពម៉ូឌែល អាចទទួលបានជា **coefficient of determination** ដូចខាងក្រោម៖
```python
score = lin_reg.score(X_train,y_train)
print('Model determination: ', score)
```
បើតម្លៃនេះស្មើ 0 មានន័យថាម៉ូដែលមិនយកទិន្នន័យបញ្ចូលចូលចិត្តនោះទេ ហើយគាត់ប្រតិបត្តិដូចជា *អ្នកទាយបង្ហាញបញ្ចូល linear អាក្រក់បំផុត* ដែលគ្រាន់តែជាតម្លៃមធ្យមនៃលទ្ធផល។ តម្លៃ 1 មានន័យថាយើងអាចទាយទម្លៃលទ្ធផលបានយ៉ាងពេញលេញ។ ក្នុងករណីរបស់យើង coefficient ប្រហែល 0.06 ដែលទាបបន្តិច។
ប្រសិនបើតម្លៃគឺ 0 វាមានន័យថា ម៉ូឌែលមិនយកទិន្នន័យអោយបានជាការបញ្ចូល និងដំណើរការជា *predictor linear អាក្រក់បំផុត* ដែលជាមធ្យមតម្លៃលទ្ធផលប៉ុណ្ណោះ។ តម្លៃ 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 ប៉ូលីណូមី
ប្រភេទមួយទៀតនៃរេហ្គ្រេស្យុងបែបជួរឈរជាមួយគ្នាគឺ រេហ្គ្រេស្យុងផូលីណូម្យ얼។ នៅពេលខ្លះ មានទំនាក់ទំនងបែបជួរឈរពីរវីរីables - ដូចជាឥដ្ឋមានទំហំនាងធំ នឹងមានតម្លៃថ្លៃខ្ពស់ជាង - ប៉ុន្តេលើកលែងទំនាក់ទំនងទាំងនេះមិនអាចបង្ហាញជាពហុប្លង់ ឬបន្ទាត់ស្របបាន ។
ប្រភេទមួយផ្សេងទៀតនៃ Linear Regression គឺ Polynomial Regression។ ខណៈពេលពេលដែលពេលខ្លះ មានទំនាក់ទំនងបន្ទាត់រវាងអថេរណ៍ - ការរំលាយបំពងត្រូវបានវាស់ចំណុះកាន់តែធំ ទីផ្សារក៏កាន់តែល្អ - ពេលខ្លះទំនាក់ទំនងទាំងនេះមិនអាចត្រូវបានគូសបង្ហាញជាល្វែងឬបន្ទាត់តែមួយបានទេ ។
✅ នៅទីនេះមាន [ឧទាហរណ៍បន្ថែម ](https://online.stat.psu.edu/stat501/lesson/9/9.8 ) នៃ ទិន្នន័យដែលអាចប្រើរេហ្គ្រេស្យុងផូលីណូម្យ얼 បាន
✅ សូមមើល [ឧទាហរណ៍បន្ថែម ](https://online.stat.psu.edu/stat501/lesson/9/9.8 ) ទិន្នន័យដែលអាចប្រើបាន Polynomial Regression
សូមមើលទំនាក់ទំនងរវាងថ្ងៃ និងតម្លៃវិញ។ តើក្រាហ្វ Scatterplot នេះមើលទៅគឺត្រូវតែវិភាគដោយបន្ទាត់ស្របទេមែន? តើតម្លៃថ្លៃអាចមានការប្រែប្រួលទេ? ក្នុងករណីនេះ អ្នកអាចសាកល្បងរេហ្គ្រេស្យុងផូលីណូម្យ얼បាន ។
មើលម្ដងទៀតលើទំនាក់ទំនងរវាង Date និង Price។ តើ scatterplot នេះមើលទៅដូចជាគួរត្រូវបានវិភាគតាមបន្ទាត់តែមួយទេ? តើតម្លៃនៃតម្លៃតម្លើងនឹងមានការធ្លាក់ឡើង? ក្នុងករណីនេះ អ្នកអាចសាកល្បង polynomial regression ។
✅ ផូលីណូម្យ얼គឺជាការសម្ដែងគ្រឹះគណិតវិទ្យាដែលអាចមានអថេរតែមួយ ឬច្រើន និងគុក័ភីស្យង់
✅ ប៉ូលីណូមីគឺជាការបង្ហាញគណិតវិទ្យាដែលអាចមានអថេរណ៍មួយឬច្រើន និងគុណលក្ខណៈ
រេហ្គ្រេស្យុងផូលីណូម្យ얼បង្កើតខ្សែពោងកោង ដើម្បីឲ្យអាចសាកសមនឹងទិន្នន័យមិនម៉ាស្សា linear បានល្អប្រសើរជាងមុន។ ក្នុងករណីរបស់យើង ប្រសិនបើបញ្ចូលអថេរពណ៌វត្ថុ `DayOfYear` ^2 ទៅក្នុងទិន្នន័យបញ្ចូល យើងគួរតែអាចតំឡើងទិន្នន័យជាមួយខ្សែ parabola ដែលមានតម្លៃអប្បបរមានៅពេលកំណត់ មួយក្នុងឆ្នាំ។
Polynomial regression បង្កើតខ្សែជារបារោងក្រោងសម្រាប់ផ្គូរផ្គងទិន្នន័យប្លែកៗសម្រាប់ការព្យាករណ៍។ ក្នុងករណីរបស់យើង ប្រសិនបើយើងបញ្ចូលអថេរ `DayOfYear` កាយក្រិតទីពីរចូល ទិន្នន័យបញ្ចូល យើងអាចជួយឱ្យត្រូវបានផ្គូរផ្គងជាមួយខ្សែប្រមាណប៉ារ៉ាបល (parabolic curve) ដែលមានតម្លៃអប្បបរមានៅចំណុច មួយក្នុងឆ្នាំ។
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 ដែលជាលើកដំបូងបន្ថែមលក្ខណៈផូលីណូម្យ얼ទៅម៉ូដែល ហើយបន្ទាប់បណ្ដុះបណ្ដាលរេហ្គ្រេស្យុង៖
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:
```python
from sklearn.preprocessing import PolynomialFeatures
@ -255,61 +254,61 @@ 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` បានផងដែរ ដើម្បីទទួលលទ្ធផលទាយ។ ខាងក្រោមជាក្រាហ្វដែលបង្ហាញទិន្នន័យសាកល្បង និងខ្សែពោងកោងតំណាង៖
ការប្រើប្រាស់ `PolynomialFeatures(2)` មានន័យថាយើងនឹងបញ្ចូលក polynomial ពីដំណើរការថ្នាក់ទីពីរទាំងអស់ ពីទិន្នន័យបញ្ចូល។ ក្នុងករណីរបស់យើង វានឹងមានតែ `DayOfYear` < sup > 2</ sup > ប៉ុណ្ណោះ ប៉ុន្តែសម្រាប់អថេរឈ្មោះ X និង Y ខុសគ្នា វានឹងបន្ថែម X< sup > 2</ sup > XY និង Y< sup > 2</ sup > ។ យើងអាចប្រើ polynomial ថ្នាក់ខ្ពស់ជាងនេះប្រសិនបើចង់បាន។
Pipeline អាចប្រើដូចជាវត្ថុ `LinearRegression` ដើម គឺយើងអាច `fit` pipeline ហើយបន្ទាប់មកប្រើ `predict` ដើម្បីទទួលបានលទ្ធផល។ នេះជាក្រាផាងបង្ហាញទិន្នន័យសាកល្បង និងខ្សែប្រមាណ៖
< img alt = "Polynomial regression" src = "../../../../translated_images/km/poly-results.ee587348f0f1f60b.webp" width = "50%" / >
ដោយប្រើរេហ្គ្រេស្យុងផូលីណូម្យ얼 យើងអាចទទួលបាន MSE ទាបជាងបន្តិច និង coefficient of determination ខ្ពស់ជាងបន្តិច ប៉ុន្តែមិនខ្លាំងណាស់ទេ។ យើងត្រូវយកចំណុចផ្សេងទៀតចូលក្នុងការពិចារណាផងដែរ !
ដោយប្រើ Polynomial Regression យើងអាចទទួលបាន MSE ទាបបន្តិច និង coefficient determination ខ្ពស់ជាង ប៉ុន្តែមិនច្រើនខ្លាំងទេ។ យើងត្រូវយកចិត្តទុកដាក់ទៅលើលក្ខណៈផ្សេងទៀតផង !
> អ្នកអាចបើកចំណាំបានថា តម្លៃថ្លៃអង្គរជាមួយខ្នងនោះមានចន្លោះពេលដែលជិតថ្ងៃ Halloween។ តើអ្នកអាចពន្យល់មូលហេតុនេះបានយ៉ាងដូចម្តេច ?
> អ្នកអាចសង្កេតឃើញថា តម្លៃបណ្ដូលរបស់ កំបោរភាគច្រើនបង្ហាញនៅក្បែរបុណ្យ Halloween។ តើធ្វើដូចម្តេចដើម្បីពន្យល់ពីនេះ ?
🎃 សូម អបអរសាទរ អ្នកទើបបង្កើតម៉ូដែលមួយដែលអាចជួយទាយតម្លៃថ្លៃនំទំពាំងបាយជូបាន។ អ្នកប្រហែលជាអាចធ្វើដំណើរការតែមួយនេះសម្រាប់ប្រភេទទំពាំងបាយជូគ្រប់ប្រភេទបានផង ប៉ុន្តែវាត្រូវការការងារលំបាក។ យើងនឹងរៀនរបៀបយកប្រភេទទំពាំងបាយជូទៅក្នុងគំរូរបស់យើងឥលូវនេះ !
🎃 អបអរសាទរ អ្នកទើបបង្កើតម៉ូឌែលអាចជួយព្យាករណ៍តម្លៃកំបោរភាគបាយបាន។ អ្នកប្រហែលជាអាចធ្វើបែបនេះសម្រាប់ប្រភេទកំបោរទាំងអស់ ប៉ុន្តែវាអាចធ្វើឱ្យធុញនឿយ។ យើងនឹងរៀនពីរបៀបយកប្រភេទកំបោរចូលទៅក្នុងម៉ូឌែល !
## លក្ខណៈពិសេសដូចជា ប្រភេទ (Categorical Features)
## លក្ខណៈប្រភេទ (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 ទេ ព្រោះវាប្រើតម្លៃលេខនោះដើម្បីបន្ថែមលទ្ធផល បូកនឹងគុក័ភីស្យង់ផ្សេងៗ ហើយទំនាក់ទំនងរវាងលេខនិងតម្លៃថ្លៃមិនមែន linear ទេ ទោះបីបញ្ជាក់ថាលេខជាតម្លៃលំដាប់ក្រោមក៏ដោយ ។
* **One-hot encoding** នឹងបម្លែងជួរឈរ `Variety` ទៅជាជួរឈរបួនគ្នា សម្រាប់ប្រភេទនីមួយៗគ្នា។ វាអាចមានតម្លៃ `1` ប្រសិនបើជួរដេកទាំងនោះនៅក្នុងប្រភេទនោះ ហើយ`0` នៅក្នុងករណីផ្សេងទៀត។ នេះមានន័យថានឹងមានគុក័ភីស្យង់បួនសម្រាប់រេហ្គ្រេស្យុង linear សម្រាប់ប្រភេទទំពាំងបាយជូ បំពេញដំបូងនៃតម្លៃថ្លៃឬ "តម្លៃបន្ថែម" សម្រាប់ប្រភេទនោះ។
* **numeric encoding** ងាយស្រួលបង្កើតតារាងប្រភេទផ្សេងៗ ហើយប្តូរឈ្មោះប្រភេទជាទីតាំងក្នុងតារាង។ នេះមិនល្អសម្រាប់ linear regression ព្រោះ linear regression ប្រើតម្លៃចំនួនជាក់លាក់របស់ index ហើយបូកលទ្ធផលដោយគុណនឹង coefficient មួយ។ នៅក្នុងករណីរបស់យើង ទំនាក់ទំនងរវាងលេខរៀងនិងតម្លៃមិនមែនជាបន្ទាត់ទេ ទោះបីយើងតម្រៀបតាមលំដាប់ជាការពិត ។
* **One-hot encoding** ជំនួបបន្ទាត់ `Variety` ជាមួយបន្ទាត់ ៤ ប្រភេទផ្សេងៗ បន្ទាត់មួយសម្រាប់ប្រភេទនីមួយៗ។ រាល់បន្ទាត់ នឹងមាន `1` ប្រសិនបើជាបន្ទាត់នៃប្រភេទនោះ និង `0` ប្រសិនបើមិនមែន។ នោះមានន័យថា មានគុណលក្ខណៈបួននៅក្នុង linear regression សម្រាប់ប្រភេទកំបោរផ្សេងៗ ដែលរួមបញ្ចូលតម្លៃចាប់ផ្តើម (ឬតម្លៃបន្ថែម) សម្រាប់ប្រភេទនោះ។
កូដខាងក្រោមបង្ហាញពីរបៀបដែលយើងអាចកូដ one-hot encoding ចំពោះប្រភេទបាន ៖
កូដខាងក្រោមបង្ហាញពីរបៀបបម្លែងប្រភេទទៅ 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
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` ឲ្យបាន ត្រឹមត្រូវ៖
ដើម្បីបណ្តុះ linear regression ជាមួយ one-hot encoded variety ជាដំណើរការបញ្ចូល បូកផ្សំពីការចាប់ផ្តើម `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` ៖
កូដដែលនៅសល់ដូចគ្នានឹងវាដែលបានប្រើខាងលើសម្រាប់បណ្តុះ Linear Regression។ ប្រសិនបើអ្នកសាកល្បង វានឹងបង្ហា ញថា mean squared error ប្រហែលដូចគ្នា ប៉ុន្តែ coefficient determination ទទួលបាន ខ្ពស់ជាង (~77%)។ ដើម្បីទទួលបានការព្យាករណ៍ត្រឹមត្រូវច្រើនទៀត អ្នកអាចយកលក្ខណៈ categorical ផ្សេងៗ និងលក្ខណៈចំនួនដូចជា `Month` ឬ `DayOfYear` មកគិតរួម។ ដើម្បីទទួលបាន array លក្ខណៈធំមួយ អ្នកអាចប្រើ `join` ៖
```python
X = pd.get_dummies(new_pumpkins['Variety']) \
@ -318,69 +317,69 @@ X = pd.get_dummies(new_pumpkins['Variety']) \
.join(pd.get_dummies(new_pumpkins['Package']))
y = new_pumpkins['Price']
```
នៅទីនេះយើងក៏យកចំណុច `City` និងប្រភេទ `Package` ចូលគណនាផង ដោយមាន MSE 2.84 (10%) និងកំណត់ត្រានៃការបញ្ជាក់ 0.94!
## រួមបញ្ចូលគ្នាទាំងអស់
នៅទីនេះ យើងក៏នឹងយក `City` និងប្រភេទ `Package` ទៅគិតផង ដែលផ្តល់ឱ្យយើង MSE 2.84 (10%) និង coefficient determination 0.94!
ដើម្បីបង្កើតម៉ូដែលល្អបំផុត យើងអាចប្រើទិន្នន័យផ្សំប្រភេទ (one-hot encoded categorical) និងចំនួន (numeric) ពីឧទាហរណ៍ខាងលើជាមួយរេហ្គ្រេស្យុងផូលីណូម្យ얼។ ខាងក្រោមជាកូដពេញលេញសម្រាប់សម្រួលរបស់អ្នក៖
## បង្ហាប់គ្រប់យ៉ាងរួមគ្នា
ដើម្បីបង្កើតម៉ូឌែលល្អបំផុត យើងអាចប្រើទិន្នន័យបញ្ចូលរួមគ្នា (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 និងកំណត់ការសម្រេច
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 |
នេះគួរតែផ្តល់ឱ្យយើងនូវ 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 |
| លក្ខណៈទាំងអស់ Polynomial | 2.23 (8.25%) | 0.97 |
🏆 ល្អណាស់! អ្នកបានបង្កើតម៉ូដែលរេហ្គ្រេស្យុងបួនលក្ខណៈក្នុងមួយមេរៀន ហើយបង្កើនគុណភាពម៉ូដែលដល់ 97%។ នៅផ្នែកចុងក្រោយអំពីរេហ្គ្រេស្យុង អ្នកនឹងរៀនអំពី Logistic Regression ដើម្បីកំណត់ប្រភេទ។
🏆 តើអ្នកបានធ្វើបានល្អ! អ្នកបង្កើតម៉ូឌែល Regression បួនក្នុងមួយមេរៀន ហើយបង្កើតគុណភាពម៉ូឌែលបានទៅដល់97%។ នៅក្នុងផ្នែកចុងក្រោយ នៃមេរៀន Regression អ្នកនឹងរៀនអំពី Logistic Regression ដើម្បីកំណត់ប្រភេទ។
---
## 🚀ការប្រកួតប្រជែង
## 🚀 បញ្ញើ
សាកល្បងអថេរផ្សេងៗគ្នាច្រើន ក្នុងកំណត់ត្រានេះ ដើម្បីមើលថាតើភាពស៊ីជម្រៅនៃទំនាក់ទំនងឆ្លើយតបដូចម្តេចទៅដោយភាពត្រឹមត្រូវរបស់ម៉ូដ ែល។
សាកល្បងអថេរផ្សេងៗគ្នាក្នុងកំណត់ត្រានេះ ដើម្បីមើលថាតើការតភ្ជាប់ទំនាក់ទំនងសមរម្យទៅប៉ុណ្ណា ជាមួយគុណភាពម៉ូឌ ែល។
## [ប្រលងបន្ទាប់ម៉ោងបង្ រៀន](https://ff-quizzes.netlify.app/en/ml/ )
## [ការប្រលងក្រោយមេ រៀន](https://ff-quizzes.netlify.app/en/ml/ )
## ការត្រួតពិនិត្យ និង សិក្សាឯករាជ្យ
## សិក្សាផ្ទាល់ខ្លួន
ក្នុងមេរៀននេះ យើងបានរៀនអំពី Linear Regression។ មានប្រភេទរេហ្គ្រេស្យុងសំខាន់ៗផ្សេងទៀត។ សូមអានអំពី Stepwise, Ridge, Lasso និង Elasticnet។ មេរៀនល្អមួយសម្រាប់សិក្សាបន្ថែមគឺ [មេរៀនស្ថិតិ ស្ទេនហ្វ័រដ៍ ](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning )
នៅ ក្នុងមេរៀននេះ យើងបានរៀនអំពី Linear Regression។ មានប្រភេទ Regression ផ្សេងទៀតដែលសំខាន់។ សូមអានអំពី Stepwise, Ridge, Lasso និង Elasticnet។ វគ្គសិក្សាល្អសម្រាប់រៀនបន្ថែមគឺ [វគ្គសិក្សារបស់ Stanford Statistical Learning ](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning )
## បេសកកម្ម
## ការបង្រៀន
[បង្កើតម៉ូ ដ ែល](assignment.md )
[បង្កើតម៉ូ ឌ ែល](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 weeks ago