26 KiB

Raw Permalink Blame History

ការណែនាំអំពីការបែងចែកចំណាត់ថ្នាក់

ក្នុងមេរៀនបួននេះ អ្នកនឹងបានសិក្សាពីចំណុចសំខាន់មួយនៃការសិក្សាម៉ាស៊ីនបែបចាស់ៗមួយ - ការបែងចែកចំណាត់ថ្នាក់។ យើងនឹងដំណើរការប្រើប្រាស់អាល់គូរីធึមបែងចំណាត់ថ្នាក់នានាជាមួយនឹងទិន្នន័យអំពីម្ហូបឆុងសាធារណៈទាំងអាស៊ីនិងឥណ្ឌា។ សូមសង្ឃឹមថាអ្នកនៅពេលនេះមានអាហារស្តុក!

ប្រារព្ធរំលឹកមុខម្ហូបប៉ាន-អាស៊ីក្នុងមេរៀនទាំងនេះ! រូបភាពដោយ Jen Looper

ការបែងចំណាត់ថ្នាក់គឺជារបៀបមួយនៃ ការសិក្សាដោយមានតំណាង ដែលមានអារម្មណ៍ស្រដៀងនឹងបច្ចេកទេសរេហ្គ្រេស្យុង។ ប្រសិនបើការសិក្សាម៉ាស៊ីនគឺស្តីពីការព្យាករណ៍តម្លៃឬឈ្មោះរបស់វត្ថុតាមរយៈទិន្នន័យ។ ការបែងចំណាត់ថ្នាក់មានពីរប្រភេទទូទៅគឺ: ការបែងចំណាត់ថ្នាក់ពីរប្រាំពីរណ៍ និង ការបែងចំណាត់ថ្នាក់ច្រើនថ្នាក់។

🎥 ចុចលើរូបភាពខាងលើសម្រាប់វីដេអូ៖ John Guttag ពី MIT បង្ហាញអំពីការបែងចំណាត់ថ្នាក់

ចងចាំ៖

រេហ្គ្រេស្យុងបន្ទាត់ បានជួយអ្នកព្យាករណ៍ទំនាក់ទំនងរវាងអថេរនានា និងធ្វើព្យាករណ៍ត្រឹមត្រូវថាតម្លៃទិន្នន័យថ្មីនឹងស្ថិតនៅកន្លែងណាអំពីបន្ទាត់នោះ។ ដូច្នេះ អ្នកអាចព្យាករណ៍ថា តម្លៃផ្លែហ្គែលនៅខែកញ្ញាឬខែធ្នូ ដូចជា។
រេហ្គ្រេស្យុងឡូហ្ស៊ីស្ទិក បានជួយអ្នករកឃើញ "ប្រភេទពីរប្រាំពីរណ៍": នៅតម្លៃតំលៃនេះ ផ្លែហ្គែលនេះពណ៌ទ្រុងឬមិនទ្រុង?

ការបែងចំណាត់ថ្នាក់ប្រើអាល់គូរីធឹមជាច្រើនដើម្បីកំណត់វិធីផ្សេងៗក្នុងការបញ្ជាក់ស្លាក ឬថ្នាក់របស់ចំណុចទិន្នន័យ។ យើងនឹងប្រើទិន្នន័យម្ហូបនេះដើម្បីមើលថាតើដោយសង្កេតមើលក្រុមគ្រឿងផ្សំមួយ អាចកំណត់បានថាម្ហូបនេះមានប្រភពពីខេត្តណាបានឬជាអាច។

ការប្រលងមុនមេរៀន

មេរៀននេះអាចប្រើបានក្នុង R!

ការណែនាំ

ការបែងចំណាត់ថ្នាក់គឺជាកម្មវិធីមួយសំខាន់សម្រាប់អ្នកស្រាវជ្រាវម៉ាស៊ីនសិក្សា និងអ្នកវិទ្យាស្ថានទិន្នន័យមួយ។ ចាប់ពីការបែងចំណាត់ថ្នាក់ពីរប្រាំពីរណ៍មូលដ្ឋាន ("អ៊ីមែលនេះជាស្គាមឬមិនមែន?"), រហូតដល់ការបែងចំណាត់ថ្នាក់រូបភាពស្មុគស្មាញ និងការបែងចំណាត់ថ្នាក់ផ្នែកដោយការមើលឃើញកុំព្យូទ័រ វាអាចមានប្រយោជន៍ជានិច្ចក្នុងការរៀបចំនូវទិន្នន័យទៅក្នុងថ្នាក់ និងសាកសួរទិន្នន័យនោះ។

ដើម្បីពន្យល់ដោយវិទ្យាសាស្ត្រនិងច្បាស់លាស់បន្ថែមវិញ វិធីសាស្ត្របែងចំណាត់ថ្នាក់របស់អ្នកបង្កើតម៉ូដែលព្យាករណ៍ដែលអនុញ្ញាតឲ្យអ្នកបំរែបំរួលទំនាក់ទំនងរវាងអថេរដំណាក់កាល ទៅកាន់អថេរបញ្ចេញ។

បញ្ហាប្រភេទពីរប្រាំពីរណ៍ និងច្រើនថ្នាក់សម្រាប់អាល់គូរីធឹមបែងចំណាត់ថ្នាក់ត្រូវដោះស្រាយ។ រូបភាពដោយ Jen Looper

មុនចាប់ផ្តើមដំណើរការសំអាតទិន្នន័យរបស់យើង មើលគំរូវាទិន្នន័យ និងរៀបចំវាសម្រាប់ភារកិច្ច ML របស់យើង សូមយើងសិក្សាអំពីវិធីផ្សេងៗដែលម៉ាស៊ីនសិក្សាអាចប្រើដើម្បីបែងចែកទិន្នន័យ។

បានដកស្រង់ពី ស្ថិតិវិទ្យា ការបែងចំណាត់ថ្នាក់ដោយប្រើម៉ាស៊ីនសិក្សាចាស់ៗប្រើលក្ខណៈពិសេស ជាទម្រង់ smoker, weight, និង age ដើម្បីកំណត់ ពលភាពនៃការកើតជំងឺ X។ ជាចំណុចសិក្សាដោយមានតំណាង ដែលស្រដៀងនឹងហាត់រេហ្គ្រេស្យុងដែលអ្នកបានធ្វើមុននេះ ទិន្នន័យរបស់អ្នកត្រូវបានដាក់ស្លាក ហើយអាល់គូរីធឹម ML ប្រើស្លាកទាំងនោះដើម្បីបែងចំណាត់ និងព្យាករណ៍ថ្នាក់ (ឬ 'លក្ខណៈពិសេស') របស់ទិន្នន័យ និងផ្ដល់វាទៅក្រុម ឬលទ្ធផលមួយ។

✅ ចំណាយពេលស្រមៃពីទិន្នន័យអំពីម្ហូបមួយ។ ម៉ូដែលច្រើនថ្នាក់អាចឆ្លើយបានអ្វី? ម៉ូដែលពីរប្រាំពីរណ៍អាចឆ្លើយបានអ្វី? បើអ្នកចង់កំណត់ថាអ្វីមួយថាតើម្ហូបណាមួយប្រើ "fenugreek" ឬទេ? បើអ្នកចង់មើលថា ប្រសិនបើមានកាបូបទំនិញពោរពេញដោយ "star anise", "artichokes", "cauliflower", និង "horseradish" អ្នកអាចបង្កើតម្ហូបឥណ្ឌាប្រភេទមួយបានឬទេ?

🎥 ចុចលើរូបភាពខាងលើសម្រាប់វីដេអូ៖ គោលបំណងទាំងមូលនៃកម្មវិធី 'Chopped' គឺក្នុង 'កាបូបសម្ងាត់' ដែលអ្នកចម្អិនម្ហូបត្រូវបង្កើតម្ហូបពីជម្រើសគ្រឿងផ្សំនានា។ ពិតជាម៉ូដែល ML នឹងជួយបានយ៉ាងច្រើន។

សួរវាគឺ 'classifier'

សំណួរដែលយើងចង់សួរពីទិន្នន័យម្ហូបនេះគឺជា សំណួរច្រើនថ្នាក់, ព្រោះយើងមានម្ហូបជាតិជាច្រើនដែលអាចប្រើបាន។ ដោយផ្អែកលើក្រុមគ្រឿងផ្សំមួយ, តើទិន្នន័យនេះនឹងស្ថិតក្នុងថ្នាក់ណា?

Scikit-learn ផ្តល់ជូននូវអាល់គូរីធឹមជាច្រើនដើម្បីប្រើបែងចំណាត់របស់ទិន្នន័យ តាមបំណង ប្រភេទបញ្ហាដែលអ្នកចង់ដោះស្រាយ។ ក្នុងមេរៀនពីរបន្ទាប់ អ្នកនឹងសិក្សាអំពីអាល់គូរីធឹមទាំងនេះ។

អនុវត្តិ - សំអាត និងសមតុល្យទិន្នន័យរបស់អ្នក

កិច្ចការដំបូងជាចាំបាច់ មុនចាប់ផ្តើមគម្រោងនេះ គឺសំអាត និង សមតុល្យ ទិន្នន័យរបស់អ្នក ដើម្បីទទួលបានលទ្ធផលល្អ។ ចាប់ផ្តើមជាមួយឯកសារ notebook.ipynb ទទេនៅមូលដ្ឋានថតនេះ។

របស់ដំបូងដែលត្រូវដំឡើងគឺ imblearn។ នេះជាបណ្ណាល័យ Scikit-learn មួយដែលអនុញ្ញាតឲ្យអ្នកសមតុល្យទិន្នន័យបានល្អប្រសើរជាងមុន (អ្នកនឹងរៀនអំពីភារកិច្ចនេះបន្ថែមបន្ទាប់ពីនេះ)។

ដើម្បីដំឡើង imblearn, ប្រើពាក្យបញ្ជា pip install ដូចខាងក្រោម៖
```
pip install imblearn
```
នាំចូលបណ្ណាល័យដែលអ្នកត្រូវការដើម្បីនាំចូលទិន្នន័យ និងបង្ហាញវីសិរម្យ បានបញ្ចូល SMOTE ពី imblearn ផងដែរ។
```
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib as mpl
import numpy as np
from imblearn.over_sampling import SMOTE
```
ឥឡូវនេះអ្នកបានត្រៀមខ្លួនសម្រាប់នាំចូលទិន្នន័យបន្ទាប់។
ភារកិច្ចបន្ទាប់គឺនាំចូលទិន្នន័យ៖
```
df  = pd.read_csv('../data/cuisines.csv')
```
ការប្រើ read_csv() នឹងអានមាតិកានៃឯកសារ csv cusines.csv ហើយដាក់វាទៅក្នុងអថេរ df។

ពិនិត្យទម្រង់ទិន្នន័យ៖

df.head()

បន្ទាត់ប្រាំដំបូងមានរូបរាងដូចខាងក្រោម៖

|     | Unnamed: 0 | cuisine | almond | angelica | anise | anise_seed | apple | apple_brandy | apricot | armagnac | ... | whiskey | white_bread | white_wine | whole_grain_wheat_flour | wine | wood | yam | yeast | yogurt | zucchini |
| --- | ---------- | ------- | ------ | -------- | ----- | ---------- | ----- | ------------ | ------- | -------- | --- | ------- | ----------- | ---------- | ----------------------- | ---- | ---- | --- | ----- | ------ | -------- |
| 0   | 65         | indian  | 0      | 0        | 0     | 0          | 0     | 0            | 0       | 0        | ... | 0       | 0           | 0          | 0                       | 0    | 0    | 0   | 0     | 0      | 0        |
| 1   | 66         | indian  | 1      | 0        | 0     | 0          | 0     | 0            | 0       | 0        | ... | 0       | 0           | 0          | 0                       | 0    | 0    | 0   | 0     | 0      | 0        |
| 2   | 67         | indian  | 0      | 0        | 0     | 0          | 0     | 0            | 0       | 0        | ... | 0       | 0           | 0          | 0                       | 0    | 0    | 0   | 0     | 0      | 0        |
| 3   | 68         | indian  | 0      | 0        | 0     | 0          | 0     | 0            | 0       | 0        | ... | 0       | 0           | 0          | 0                       | 0    | 0    | 0   | 0     | 0      | 0        |
| 4   | 69         | indian  | 0      | 0        | 0     | 0          | 0     | 0            | 0       | 0        | ... | 0       | 0           | 0          | 0                       | 0    | 0    | 0   | 0     | 1      | 0        |

ទទួលបានព័ត៌មានអំពីទិន្នន័យនេះដោយហៅមុខងារ info()៖
```
df.info()
```
លទ្ធផលដែលអ្នកទទួលបានមានរូបរាងដូចខាងក្រោម៖
```
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 2448 entries, 0 to 2447
Columns: 385 entries, Unnamed: 0 to zucchini
dtypes: int64(384), object(1)
memory usage: 7.2+ MB
```

អនុវត្តិ - រៀនអំពីម្ហូប

ឥឡូវនេះការងារចាប់ផ្តើមទៅកាន់ជំហានចាប់អារម្មណ៍បន្ថែម។ ចូរផ្សព្វផ្សាយការបែងចែកទិន្នន័យ តាមម្ហូប

គូសទិន្នន័យជាកំណត់ប្លង់ដកថ្នេរជាតារាងដោយហៅ barh()៖
```
df.cuisine.value_counts().plot.barh()
```
មានម្ហូបច្រើនណាស់ ប៉ុន្តែការបែងចែកទិន្នន័យមិនស្មើល្អទេ។ អ្នកអាចដោះស្រាយបាន! មុននោះ សូមស្វែងយល់បន្ថែម។

រកមើលថាតើមានទិន្នន័យប៉ុន្មានក្នុងមួយម្ហូប ហើយបោះពុម្ពវាចេញ៖

thai_df = df[(df.cuisine == "thai")]
japanese_df = df[(df.cuisine == "japanese")]
chinese_df = df[(df.cuisine == "chinese")]
indian_df = df[(df.cuisine == "indian")]
korean_df = df[(df.cuisine == "korean")]

print(f'thai df: {thai_df.shape}')
print(f'japanese df: {japanese_df.shape}')
print(f'chinese df: {chinese_df.shape}')
print(f'indian df: {indian_df.shape}')
print(f'korean df: {korean_df.shape}')

លទ្ធផលដូចនេះ៖

thai df: (289, 385)
japanese df: (320, 385)
chinese df: (442, 385)
indian df: (598, 385)
korean df: (799, 385)

ស្វែងរកគ្រឿងផ្សំ

ឥឡូវនេះ អ្នកអាចស្ទង់ជ្រៅទៅក្នុងទិន្នន័យ និងស្វែងរកគ្រឿងផ្សំទូទៅក្នុងមួយម្ហូប។ អ្នកគួរតែសំអាតទិន្នន័យដែលមានកំហុសច្រើនបណ្ដាលឲ្យមានការភាន់ច្រឡំរវាងម្ហូប ដូចនេះ ចូររៀនអំពីបញ្ហានេះ។

បង្កើតមុខងារ create_ingredient() ក្នុង Python ដើម្បីបង្កើត dataframe គ្រឿងផ្សំ។ មុខងារនេះនឹងចាប់ផ្តើមដោយបោះបង់ស្ថំពត៌មានមិនមានប្រយោជន៍ ហើយតម្រៀបគ្រឿងផ្សំតាមចំនួន៖
```
def create_ingredient_df(df):
    ingredient_df = df.T.drop(['cuisine','Unnamed: 0']).sum(axis=1).to_frame('value')
    ingredient_df = ingredient_df[(ingredient_df.T != 0).any()]
    ingredient_df = ingredient_df.sort_values(by='value', ascending=False,
    inplace=False)
    return ingredient_df
```
ឥឡូវនេះ អ្នកអាចប្រើមុខងារនោះ ដើម្បីដឹងពីចំនួនគ្រឿងផ្សំដែលពេញនិយមចំនួនដប់ខាងលើតាមមុខម្ហូប។

ហៅ create_ingredient() ហើយគូសវាបញ្ចូល barh()៖

thai_ingredient_df = create_ingredient_df(thai_df)
thai_ingredient_df.head(10).plot.barh()

ធ្វើដូចគ្នាសម្រាប់ទិន្នន័យជប៉ុន៖

japanese_ingredient_df = create_ingredient_df(japanese_df)
japanese_ingredient_df.head(10).plot.barh()

ឥឡូវសម្រាប់គ្រឿងផ្សំចិន៖

chinese_ingredient_df = create_ingredient_df(chinese_df)
chinese_ingredient_df.head(10).plot.barh()

គូសគ្រឿងផ្សំឥណ្ឌា៖

indian_ingredient_df = create_ingredient_df(indian_df)
indian_ingredient_df.head(10).plot.barh()

ចុងក្រោយ គូសគ្រឿងផ្សំកូរ៉េ៖

korean_ingredient_df = create_ingredient_df(korean_df)
korean_ingredient_df.head(10).plot.barh()

ឥឡូវនេះ បោះបង់គ្រឿងផ្សំពេញនិយមបំផុតដែលបង្កការភាន់ច្រឡំរវាងម្ហូបតាមរយៈការហៅ drop()៖

មនុស្សគ្រប់គ្នាស្រឡាញ់បាយ, ខ្ទឹម និង ខ្ទិះខ្ទិះ!
```
feature_df= df.drop(['cuisine','Unnamed: 0','rice','garlic','ginger'], axis=1)
labels_df = df.cuisine #.មិនម្តង()
feature_df.head()
```

សមតុល្យទិន្នន័យ

ឥឡូវនេះ អ្នកបានសំអាតទិន្នន័យហើយ ប្រើ SMOTE - "វិធីសាស្ត្របង្កើតគំរូបន្ថែមធម្មតា" - ដើម្បីសមតុល្យវា។

ហៅ fit_resample(), វិធីសាស្ត្រនេះបង្កើតគំរូថ្មីសម្រាប់នាំចេញតាមរយៈការបញ្ចូល។
```
oversample = SMOTE()
transformed_feature_df, transformed_label_df = oversample.fit_resample(feature_df, labels_df)
```
ដោយសមតុល្យទិន្នន័យ អ្នកនឹងទទួលបានលទ្ធផលល្អជាងពេលបែងចំណាត់វា។ សូមគិតអំពីបែងចំណាត់ពីរប្រាំពីរណ៍។ ប្រសិនបើភាគច្រើននៃទិន្នន័យមានថ្នាក់មួយថ្នាក់ណាមួយ ម៉ូដែល ML ចូលចិត្តទាយថា ថ្នាក់នោះកើតឡើងច្រើនជាងគេ ដោយសារតែវាមានទិន្នន័យច្រើន។ ការសមតុល្យទិន្នន័យ ជួយដកជម្រុញនៃទិន្នន័យហួសហេតុនั้น។

ឥឡូវអ្នកអាចពិនិត្យចំនួនស្លាកក្នុងគ្រឿងផ្សំ៖

print(f'new label count: {transformed_label_df.value_counts()}')
print(f'old label count: {df.cuisine.value_counts()}')

លទ្ធផលរបស់អ្នកដូចនេះ៖

new label count: korean      799
chinese     799
indian      799
japanese    799
thai        799
Name: cuisine, dtype: int64
old label count: korean      799
indian      598
chinese     442
japanese    320
thai        289
Name: cuisine, dtype: int64

ទិន្នន័យបានស្អាតស្អំ សមតុល្យហើយឆ្ងាញ់ណាស់!

ជំហានចុងក្រោយ គឺរក្សាទុកទិន្នន័យមានសមតុល្យរបស់អ្នក ដែលរួមមានស្លាក និងលក្ខណៈពិសេស ទៅក្នុង dataframe ថ្មីដែលអាចនាំចេញទៅឯកសារមួយបាន៖
```
transformed_df = pd.concat([transformed_label_df,transformed_feature_df],axis=1, join='outer')
```
អ្នកអាចមើលទិន្នន័យម្ដងទៀតដោយប្រើ transformed_df.head() និង transformed_df.info()។ រក្សាទុកច្បាប់មួយនៃទិន្នន័យសម្រាប់ប្រើនៅមេរៀនក្រោយ៖
```
transformed_df.head()
transformed_df.info()
transformed_df.to_csv("../data/cleaned_cuisines.csv")
```
CSV ថ្មីនេះឥឡូវនេះអាចរកបាននៅក្នុងថតទិន្នន័យមូលដ្ឋាន។

🚀បញ្ហាកម្រិតខ្ពស់

មាតិកានេះមានទិន្នន័យច្រើនដែលគួរឱ្យចាប់អារម្មណ៍។ សូមស្ទង់មើលថាតើថត data មានទិន្នន័យណាមួយដែលសមស្របសម្រាប់ការបែងចំណាត់ពីរប្រាំពីរណ៍ ឬច្រើនថ្នាក់? តើសំណួរអ្វីដែលអ្នកចង់សួរពីទិន្នន័យនោះ?

ការប្រលងក្រោយមេរៀន

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

ស្វែងយល់អំពី API នៃ SMOTE។ តើវាភ្ជាប់នឹងការប្រើប្រាស់ពីរបៀបណា? តើវាដោះស្រាយបញ្ហាអ្វីខ្លះ?

កិច្ចការត្រូវបំពេញ

ស៊ើបអង្កេតវិធីសាស្ត្របែងចំណាត់ថ្នាក់

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

26 KiB Raw Permalink Blame History