ML-For-Beginners/translations/km/2-Regression/3-Linear

បង្កើតម៉ូឌែលផ្សារ​ដោយប្រើ Scikit-learn: ផ្សារ​បួន​របៀប

សម្គាល់​សម្រាប់អ្នកចាប់ផ្ដើម

ការ​ផ្សារ​រៀប​រ៉េ​ឌី​ស្យុងត្រូវបានប្រើនៅពេលដែលយើងចង់ទាយទោល​តម្លៃ ចំនួន​ស៊ីផ៍ (ឧទាហរណ៍ តម្លៃផ្ទះ, សីតុណ្ហភាព ឬ លក់ចេញ)។ វាដំណើរការដោយស្វែងរករបារភាព​តម្រាស់​មួយ​ដែល​តំណាងឲ្យទំនាក់ទំនង​រវាង​លក្ខណៈបញ្ចូល និងលទ្ធផល​បាន​ល្អ​បំផុត។

​នៅក្នុងមេរៀន​នេះ​យើងផ្តោតលើការយល់ដឹងពីគំនិតមុនពេលស្រាវជ្រាវបច្ចេកវិទ្យាស្រាវជ្រាវផ្សារ​លំដាប់ខ្ពស់បន្ថែមទៀត។

រូបភាពព័ត៌មានដោយ Dasani Madipalli

សំណួរណែនាំមុនមេរៀន

មេរៀននេះមានជាជម្រើសជាភាសា R!

ការណែនាំ

ចំពោះពេលនេះ អ្នកបានសិក្សាដឹងថាផ្សាររៀបរាប់គឺជាអ្វីជាមួយទិន្នន័យគំរូដែលបានប្រមូលពីឧបករណ៍តម្លៃផ្លែផ្អែខោចដែលយើងនឹងប្រើនៅក្នុងមេរៀននេះ។ អ្នកក៏បានធ្វើការមើលឃើញវាតាមរយៈ Matplotlib ផងដែរ។

ឥឡូវនេះ អ្នករួចរាល់ក្នុងការជ្រៀតចូលជ្រាលជ្រៅចំពោះផ្សាររៀបរាប់សម្រាប់ ML។ ខណៈពេលដែលការមើលឃើញឲ្យអ្នកយល់ដឹងពីទិន្នន័យ ព្រះរាជអំណាចពិតប្រាកដរបស់ការសិក្សាម៉ាស៊ីនក្នុងការមានភាពពី ការបណ្តុះបណ្តាលម៉ូឌែល។ ម៉ូឌែលត្រូវបានបណ្តុះបណ្តាលលើទិន្នន័យប្រវត្តិសាស្ត្រដើម្បីឆាប់យល់ពីការទាក់ទងរវាងទិន្នន័យ និងអនុញ្ញាតឲ្យអ្នកទាយទោលលទ្ធផលសម្រាប់ទិន្នន័យថ្មី ដែលម៉ូឌែលមិនបានឃើញពីមុន។

នៅក្នុងមេរៀននេះ អ្នកនឹងរៀនបន្ថែមអំពីប្រភេទផ្សាររៀបរាប់ពីរ: ផ្សាររៀបរាប់រាងតែមួយមូលដ្ឋាន និង ផ្សាររៀបរាប់ពហុបូឡីណូម្យែល រួមជាមួយគណិតវិទ្យាផ្នែកខ្លះដែលគាំទ្របច្ចេកទេសទាំងនេះ។ ម៉ូឌែលទាំងនេះនឹងអនុញ្ញាតឲ្យយើងទាយតម្លៃផ្លែផ្អែខោចដោយផ្អែកលើទិន្នន័យបញ្ចូលផ្សេងៗ។

🎥 ចុចរូបភាពខាងលើសម្រាប់មើលវីដេអូបែបខ្លីអំពីផ្សាររៀបរាប់រាងតែ្មួយមូលដ្ឋាន។

លើកទូលាយកម្មវិធីសិក្សានេះ យើងគិតថា មានចំណេះដឹងគណិតវិទ្យា​តិចតួច ប៉ុន្តែទាមទារឱ្យមានភាពងាយស្រួលសម្រាប់សិស្សដែលមកពីវិស័យផ្សេងទៀត ដូច្នេះសូមប្រយ័ត្នមានកំណត់សម្គាល់ 🧮 ការហៅចេញ វិចារណាធិការប្រើស្លាកបាច់បិទ និងឧបករណ៍អប់រំផ្សេងៗសម្រាប់ជួយឲ្យយល់។

លក្ខណ្ឌមុនបច្ចេកទេស

អ្នកគួរតែស្គាល់រចនាសម្ព័ន្ធទិន្នន័យផ្លែផ្អែខោចដែលយើងកំពុងពិនិត្យឥឡូវនេះ។ អ្នកអាចរកបានវាត្រូវបានផ្ទុករួចហើយ និងបានសម្អាតរួចក្នុងឯកសារ notebook.ipynb នៃមេរៀននេះ។ ក្នុងឯកសារ គឺបង្ហាញតម្លៃផ្លែផ្អែខោចប្រចាំមួយកំប៉ិលក្នុងតារាងទិន្នន័យថ្មី។ ដូច្នេះប្រាកដថាអ្នកអាចរត់កំណត់ត្រាតំណាងទាំងនេះនៅក្នុងកណ្តុររបស់ Visual Studio Code។

ការរៀបចំ

ដើម្បីរំលឹក អ្នកកំពុងផ្ទុកទិន្នន័យនេះដើម្បីសួរចំឡើយពីវា។

• តើពេលណា​ជា​ពេលល្អបំផុតក្នុងការទិញផ្លែផ្អែខោច?
• តើតម្លៃអ្វីដែលខ្ញុំអាចរំពឹងទុកចំពោះប្រអប់ផ្លែផ្អែខោចតូច?
• តើខ្ញុំគួរទិញវាក្នុងធុងក៍មួយពាក់កណ្តាលកំប៉ិល ឬដោយប្រអប់ 1 1/9 កំប៉ិល? អើយ! យើងសូមលត់ចូលទៅក្នុងទិន្នន័យនេះបន្ថែម។

ក្នុងមេរៀនមុន អ្នកបានបង្កើតតារាងតំណាង Pandas ហើយផ្ទុកវានៅជុំវិញផ្នែកមួយនៃឯកសារដើម ដោយប្រើការតម្រឹមតម្លៃផ្ទាល់មួយកំប៉ិល។ ប៉ុន្តែបច្ចុប្បន្ននេះ អ្នកអាចប្រមូលបានត្រឹមតែប្រហែល ៤០០ចំណុចទិន្នន័យហើយត្រឹមតែសម្រាប់ខែរដូវស្លឹកឈើជ្រុះតែប៉ុណ្ណោះ។

មើលទិន្នន័យដែលបានផ្ទុករួចជាមុនក្នុងកំណត់ត្រារួមនៅក្នុងមេរៀននេះ។ ទិន្នន័យត្រូវបានផ្ទុករួចហើយ និងបានចុះតំណាងតាមរយៈ scatterplot ដើម្បីបង្ហាញទិន្នន័យតាមខែ។ ប្រហែលជាយើងអាចយកព័ត៌មានជាក់លាក់បន្ថែមអំពីលក្ខណៈទិន្នន័យដោយសម្អាតវាបន្ថែមទៀត។

សន្ទស្សន៍ផ្សារ​រៀបរាប់រាងតែមួយ

ដូចដែលអ្នកបានរៀនក្នុងមេរៀន១ គោលបំណងនៃសមាហរណកម្ម Linear Regression គឺដើម្បីគូសបន្ទាត់មួយដែល:

• បង្ហាញទំនាក់ទំនងអថេរ។ បង្ហាញទំនាក់ទំនងរវាងអថេរ
• ធ្វើការទាយទោល។ ធ្វើការទាយទោលយ៉ាងត្រឹមត្រូវថាចំណុចទិន្នន័យថ្មីនឹងស្ថិតនៅកន្លែងណាជិតបន្ទាត់នោះ។

សិក្សារៀបរាប់ប្រើមធ្យោបាយ Least-Squares Regression ជាទូទៅក្នុងការគូសបន្ទាត់ប្រភេទនេះ។ ពាក្យ "Least-Squares" មានន័យពីដំណើរការកាត់បន្ថយកំហុសសរុបក្នុងម៉ូឌែលយើង។ សម្រាប់ចំណុចទិន្នន័យរាល់គឺយើងវាស់ចម្ងាយឈរ (ហៅថា residual) រវាងចំណុចពិត និងបន្ទាត់ផ្សារ។

យើងសម្រួលចម្ងាយទាំងនេះដល់កំរិតក្រោមពីហេតុផលពីរចម្បង៖

1. ទំហំលើទិសដៅ៖ យើងចង់ដាក់តម្លៃកំហុស -5 និង +5 ដូចគ្នា។ ការបង្រួចគុណ​​បង្កើតអោយតម្លៃទាំងអស់ជាស្រប។

2. ពិនិត្យសំណុំនៃចំណុចក្រៅ៖ ការបង្រួចគុណធ្វើឲ្យកំហុសធំៗទទួលបានទំងន់ច្រើនជាង ហើយបណ្តាលឲ្យបន្ទាត់នៅជិតចំណុចចម្ងាយ។

បន្ទាប់មកយើងបូកតម្លៃក្រោមគុណទាំងនេះទាំងឡាយគ្នា។ គោលដៅគឺរកបន្ទាត់ជាក់លាក់មួយដែលបូកចុងក្រោយនេះតិចជាងគេ (តម្លៃតិចបំផុត)—ហេតុនេះហៅថា "Least-Squares"។

🧮 បង្ហាញគណិតវិទ្យា

បន្ទាត់នេះ ដែលហៅថា បន្ទាត់ត្រូវគ្នា អាចបញ្ចេញដោយសមីការ:

Y = a + bX

X គឺជា 'អថេរពន្យល់'។ Y គឺជា 'អថេរពឹងផ្អែក'។ លំនឹងបន្ទាត់គឺ b ហើយ a គឺ កន្លែងឆ្លងដែក y-intercept ដែលសំដៅតម្លៃ Y នៅពេល X = 0។

ជំហានដំបូង គណនាលំនឹង b។ រូបភាពព័ត៌មានដោយ Jen Looper

ផ្ទុះពីនេះ និងបើសិនវាចង់បង្ហាញពីសំណួរដើមទិន្នន័យ​ផ្លែផ្អែខោច៖ "ទាយតម្លៃផ្លែផ្អែខោចមួយក្នុងមួយកំប៉ិល តាមខែ" គឺ X នឹងសំដៅតម្លៃ និង Y នឹងសំដៅខែក្នុងការលក់។

គណនាតម្លៃ Y។ ប្រសិនបើអ្នកប្រាក់តម្លៃប្រហែល $4 វាត្រូវតែជាខែ មេសា! រូបភាពព័ត៌មានដោយ Jen Looper

គណិតវិទ្យាដែលគណនាបន្ទាត់ត្រូវបង្ហាញលំនឹងបន្ទាត់ ដែលត្រូវអាស្រ័យលើការឆ្លងដែក ឬកន្លែងដែល Y មានតម្លៃនៅពេល X = 0។

អ្នកអាចមើលវិធីសាស្រ្តគណនាចំនួនទាំងនេះនៅគេហទំព័រ Math is Fun។ បន្ថែមទៀត អ្នកអាចចូលមើល លេខាគណនាតាម Least-squares ដើម្បីងាយយល់ពីរបៀបលេខមានឥទ្ធិពលដល់បន្ទាត់។

ទំនាក់ទំនងសមាមាត្រ (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។ យើងបានបំពេញជំហានសម្អាតដូចមុន និងគណនាជួរឈរប្រចាំថ្ងៃ DayOfYear ដោយប្រើបំណែកការបង្ហាញដូចខាងក្រោម៖

day_of_year = pd.to_datetime(pumpkins['Date']).apply(lambda dt: (dt-datetime(dt.year,1,1)).days)

ឥឡូវនេះដោយអ្នកបានយល់ពីគណិតវិទ្យានៃផ្សាររៀបរាប់រាងតែមួយវិញ សូមបង្កើតម៉ូឌែលផ្សារ​រួម​ដើម្បីមើលថាតើយើងអាចទាយថា ប្រអប់ផ្លែផ្អែខោចណាមួយនឹងមានតម្លៃផ្លែផ្អែខោចល្អបំផុត។ អ្នកដែលទិញផ្លែផ្អែខោចសម្រាប់ស្រុកផ្លែផ្អែខោចនៅថ្ងៃបុណ្យប្រហែលនឹងចង់បានព័ត៍មាននេះដើម្បីអាចលំអៀងការទិញប្រអប់ផ្លែផ្អែខោចរបស់ពួកគេ។

ការស្វែងរកទំនាក់ទំនងសមាមាត្រ

🎥 ចុចរូបភាពខាងលើសម្រាប់មើលវីដេអូសង្ខេបអំពីទំនាក់ទំនងសមាមាត្រ។

ពីមេរៀនមុន អ្នកប្រហែលជាបានឃើញថាតម្លៃមធ្យមសម្រាប់ខែផ្សេងៗមើលទៅដូចជា:

នេះបង្ហាញថាគួរតែមានទំនាក់ទំនងមួយ និងយើងអាចសាកល្បងបណ្តុះម៉ូឌែល Linear Regression ដើម្បីទាយទំនាក់ទំនងរវាង Month និង Price ឬស្របពេល DayOfYear និង Price។ នេះជាការបង្ហាញទិន្នន័យ scatterplot មួយបង្ហាញពីទំនាក់ទំនងចុងក្រោយ៖

យើងមកមើលថាតើមានទំនាក់ទំនងសមាមាត្រដែលប្រើបានតាម corr function ដែរឬ?

print(new_pumpkins['Month'].corr(new_pumpkins['Price']))
print(new_pumpkins['DayOfYear'].corr(new_pumpkins['Price']))

មើលទៅសមាមាត្រមានតិច គឺ -0.15 សម្រាប់ Month និង -0.17 សម្រាប់ DayOfMonth ប៉ុន្តែអាចមានទំនាក់ទំនងសំខាន់ផ្សេងទៀត។ វាមើលទៅដូចជាមានក្រុមតម្លៃផ្សេងៗរបស់ផ្លែផ្អែខោចផ្សេងៗ។ ដើម្បីបញ្ជាក់សំណល់នេះ យើងមកគូសម៉ូដែលផ្លែផ្អែខោចនីតិវិធីដោយពណ៌ផ្សេងៗគ្នា។ ដោយបញ្ជូនប៉ារ៉ាម៉ែត្រax ទៅកម្មវិធីគូស scatterplot អ្នកអាចគូសចំណុចទាំងអស់នៅលើតារាងតែមួយ។

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)

ការស៊ើបអង្កេតនិងបង្ហាញថាប្រភេទផ្លែប៉ះពាល់ជាងកាលបរិច្ឆេទលក់។ អ្នកអាចមើលមើលវាពីក្រាលបន្ទាត់​ចំនួនជាប់គ្នា៖

new_pumpkins.groupby('Variety')['Price'].mean().plot(kind='bar')

យើងយកចំណុចមានចំណាប់អារម្មណ៍មួយ គឺ ‘pie type’ និងមើលឥទ្ធិពលរបស់កាលបរិច្ឆេទលើតម្លៃ៖

pie_pumpkins = new_pumpkins[new_pumpkins['Variety']=='PIE TYPE']
pie_pumpkins.plot.scatter('DayOfYear','Price') 

បើយើងគណនាសមាមាត្ររវាង Price និង DayOfYear ដោយប្រើ corr វានឹងត្រឹមតែប្រហែលជា -0.27 - មានន័យថាការបណ្តុះម៉ូឌែលទាយទោលមានទំនាក់ទំនងហើយ។

មុននឹងបណ្តុះម៉ូឌែល Linear Regression វាជារឿងសំខាន់ក្នុងការត្រួតពិនិត្យថាទិន្នន័យរបស់យើងបានស្អាត។ Linear Regression មិនប្រសើរជាមួយអថេរបាត់បង់ ដូច្នេះវាត្រូវបានណែនាំឲ្យកម្ចាត់អថេរទទេទាំងអស់៖

pie_pumpkins.dropna(inplace=True)
pie_pumpkins.info()

មុខងារផ្សេងគ្នាគឺដាក់បញ្ចូលតម្លៃទទេនូវតម្លៃមធ្យមពីជួរឈរត្រូវទាក់ទង។

ផ្សាររៀបរាប់រាងតែមួយសាមញ្ញ

🎥 ចុចរូបភាពខាងលើសម្រាប់មើលវីដេអូទាំងមូលអំពីការបណ្តុះម៉ូឌែល Linear និង Polynomial Regression។

ដើម្បីបណ្តុះម៉ូឌែល Linear Regression របស់យើង យើងនឹងប្រើបណ្ណាល័យ Scikit-learn។

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 ផ្សេងៗ៖

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 ដើម្បីធានាការផ្ទៀងផ្ទាត់ម៉ូឌែលបន្ទាប់ពីបណ្តុះ៖

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

ចុងក្រោយ ការបណ្តុះម៉ូឌែល Linear Regression ជាក់ស្តែង ត្រូវការតែពីរបន្ទាត់កូដ។ យើងកំណត់វត្ថុ LinearRegression ហើយភ្ជាប់វានៅលើទិន្នន័យដោយវិធីសាស្រ្ត fit៖

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) ដែលជាមធ្យមនៃខុសគ្នារវាងតម្លៃរំពឹងទុក និងតម្លៃទាយដែលបានក្រោមភាពឡើងវិញ។

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 ដែលអាចទទួលបានដូចខាងក្រោម៖

score = lin_reg.score(X_train,y_train)
print('Model determination: ', score)

បើតម្លៃនេះស្មើ 0 មានន័យថាម៉ូដែលមិនយកទិន្នន័យបញ្ចូលចូលចិត្តនោះទេ ហើយគាត់ប្រតិបត្តិដូចជា អ្នកទាយបង្ហាញបញ្ចូល linear អាក្រក់បំផុត ដែលគ្រាន់តែជាតម្លៃមធ្យមនៃលទ្ធផល។ តម្លៃ 1 មានន័យថាយើងអាចទាយទម្លៃលទ្ធផលបានយ៉ាងពេញលេញ។ ក្នុងករណីរបស់យើង coefficient ប្រហែល 0.06 ដែលទាបបន្តិច។

យើងក៏អាចបង្ហាញទិន្នន័យសាកល្បង រួមជាមួយខ្សែរេហ្គ្រេស្យុង ដើម្បីឲ្យយល់ច្បាស់ថារេហ្គ្រេស្យុងធ្វើការយ៉ាងដូចម្តេច៖

plt.scatter(X_test,y_test)
plt.plot(X_test,pred)

រេហ្គ្រេស្យុងផូលីណូម្យ얼

ប្រភេទមួយទៀតនៃរេហ្គ្រេស្យុងបែបជួរឈរជាមួយគ្នាគឺ រេហ្គ្រេស្យុងផូលីណូម្យ얼។ នៅពេលខ្លះ មានទំនាក់ទំនងបែបជួរឈរពីរវីរីables - ដូចជាឥដ្ឋមានទំហំនាងធំ នឹងមានតម្លៃថ្លៃខ្ពស់ជាង - ប៉ុន្តេលើកលែងទំនាក់ទំនងទាំងនេះមិនអាចបង្ហាញជាពហុប្លង់ ឬបន្ទាត់ស្របបាន។

✅ នៅទីនេះមាន ឧទាហរណ៍បន្ថែម នៃទិន្នន័យដែលអាចប្រើរេហ្គ្រេស្យុងផូលីណូម្យ얼បាន

សូមមើលទំនាក់ទំនងរវាងថ្ងៃ និងតម្លៃវិញ។ តើក្រាហ្វ Scatterplot នេះមើលទៅគឺត្រូវតែវិភាគដោយបន្ទាត់ស្របទេមែន? តើតម្លៃថ្លៃអាចមានការប្រែប្រួលទេ? ក្នុងករណីនេះ អ្នកអាចសាកល្បងរេហ្គ្រេស្យុងផូលីណូម្យ얼បាន។

✅ ផូលីណូម្យ얼គឺជាការសម្ដែងគ្រឹះគណិតវិទ្យាដែលអាចមានអថេរតែមួយ ឬច្រើន និងគុក័ភីស្យង់

រេហ្គ្រេស្យុងផូលីណូម្យ얼បង្កើតខ្សែពោងកោង ដើម្បីឲ្យអាចសាកសមនឹងទិន្នន័យមិនម៉ាស្សា linear បានល្អប្រសើរជាងមុន។ ក្នុងករណីរបស់យើង ប្រសិនបើបញ្ចូលអថេរពណ៌វត្ថុ DayOfYear^2 ទៅក្នុងទិន្នន័យបញ្ចូល យើងគួរតែអាចតំឡើងទិន្នន័យជាមួយខ្សែ parabola ដែលមានតម្លៃអប្បបរមានៅពេលកំណត់មួយក្នុងឆ្នាំ។

Scikit-learn មាន pipeline API ដែលមានប្រយោជន៍ ដើម្បីតភ្ជាប់ជំហានដំណើរការទិន្នន័យផ្សេងៗគ្នា។ pipeline គឺជាសង្ស័យនៃ estimators។ ក្នុងករណីរបស់យើង យើងនឹងបង្កើត pipeline ដែលជាលើកដំបូងបន្ថែមលក្ខណៈផូលីណូម្យ얼ទៅម៉ូដែល ហើយបន្ទាប់បណ្ដុះបណ្ដាលរេហ្គ្រេស្យុង៖

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។

🎥 ចុចរូបភាពខាងលើសម្រាប់វីដេអូជាសង្ខេបអំពីការប្រើលក្ខណៈពិសេសឈ្មោះដូចជាប្រភេទ។

នៅទីនេះ អ្នកអាចមើលថាតម្លៃថ្លៃមធ្យមអាស្រ័យលើប្រភេទ៖

ដើម្បីយកប្រភេទចូលក្នុងគំរូបាន ត្រូវបម្លែងវាទៅជាទម្រង់លេខឬ encodeវា។ មានវិធីជាច្រើនក្នុងការធ្វើៈ

• numeric encoding សាមញ្ញ នឹងបង្កើតតារាងប្រភេទផងដែរ ហើយបម្លែងឈ្មោះប្រភេទជាលេខតែម្ដងក្នុងតារាង។ នេះមិនមែនជាគំនិតល្អសម្រាប់រេហ្គ្រេស្យុងរេហ្គ្រេស្យុង linear ទេ ព្រោះវាប្រើតម្លៃលេខនោះដើម្បីបន្ថែមលទ្ធផល បូកនឹងគុក័ភីស្យង់ផ្សេងៗ ហើយទំនាក់ទំនងរវាងលេខនិងតម្លៃថ្លៃមិនមែន linear ទេ ទោះបីបញ្ជាក់ថាលេខជាតម្លៃលំដាប់ក្រោមក៏ដោយ។
• One-hot encoding នឹងបម្លែងជួរឈរ Variety ទៅជាជួរឈរបួនគ្នា សម្រាប់ប្រភេទនីមួយៗគ្នា។ វា​អាចមានតម្លៃ 1 ប្រសិនបើជួរដេកទាំងនោះនៅក្នុងប្រភេទនោះ ហើយ0 នៅក្នុងករណីផ្សេងទៀត។ នេះមានន័យថានឹងមានគុក័ភីស្យង់បួនសម្រាប់រេហ្គ្រេស្យុង linear សម្រាប់ប្រភេទទំពាំងបាយជូ បំពេញដំបូងនៃតម្លៃថ្លៃឬ "តម្លៃបន្ថែម" សម្រាប់ប្រភេទនោះ។

កូដខាងក្រោមបង្ហាញពីរបៀបដែលយើងអាចកូដ one-hot encoding ចំពោះប្រភេទបាន៖

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 ឲ្យបានត្រឹមត្រូវ៖

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៖

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) ពីឧទាហរណ៍ខាងលើជាមួយរេហ្គ្រេស្យុងផូលីណូម្យ얼។ ខាងក្រោមជាកូដពេញលេញសម្រាប់សម្រួលរបស់អ្នក៖

# រៀបចំទិន្នន័យបណ្ដុះបណ្ដាល
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 ដើម្បីកំណត់ប្រភេទ។

---

🚀ការប្រកួតប្រជែង

សាកល្បងអថេរផ្សេងៗគ្នាច្រើនក្នុងកំណត់ត្រានេះ ដើម្បីមើលថាតើភាពស៊ីជម្រៅនៃទំនាក់ទំនងឆ្លើយតបដូចម្តេចទៅដោយភាពត្រឹមត្រូវរបស់ម៉ូដែល។

ប្រលងបន្ទាប់ម៉ោងបង្រៀន

ការត្រួតពិនិត្យ និង សិក្សាឯករាជ្យ

ក្នុងមេរៀននេះ យើងបានរៀនអំពី Linear Regression។ មានប្រភេទរេហ្គ្រេស្យុងសំខាន់ៗផ្សេងទៀត។ សូមអានអំពី Stepwise, Ridge, Lasso និង Elasticnet។ មេរៀនល្អមួយសម្រាប់សិក្សាបន្ថែមគឺ មេរៀនស្ថិតិ ស្ទេនហ្វ័រដ៍

បេសកកម្ម

បង្កើតម៉ូដែល

---

ការបដិសេធ៖
ឯកសារនេះត្រូវបានបកប្រែដោយប្រើសេវាកម្មបកប្រែ AI Co-op Translator។ ខណៈពេលដែលយើងខិតខំប្រឹងប្រែងឱ្យមានភាពត្រឹមត្រូវ សូមយល់ដឹងថាការបកប្រែដោយស្វ័យប្រវត្តិអាចមានកំហុសឬភាពមិនត្រឹមត្រូវ។ ឯកសារដើមក្នុងភាសាដើមគួរត្រូវបានគិតថាជាដើមប្រភពដែលមានអំណាច។ សម្រាប់ព័ត៌មានសំខាន់ៗ គ្រាន់តែផ្តល់អនុសាសន៍ឱ្យប្រើការបកប្រែដោយមនុស្សជំនាញវិជ្ជាជីវៈ។ យើងមិនទទួលខុសត្រូវចំពោះការយល់ច្រឡំឬការបកស្រាយខុសពីការប្រើប្រាស់ការបកប្រែនេះឡើយ។