You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
341 lines
34 KiB
341 lines
34 KiB
# ការបំពេញទិន្នន័យ: ការរៀបចំទិន្នន័យ
|
|
|
|
| ](../../sketchnotes/08-DataPreparation.png)|
|
|
|:---:|
|
|
|ការរៀបចំទិន្នន័យ - _Sketchnote ដោយ [@nitya](https://twitter.com/nitya)_ |
|
|
|
|
## [ការប្រឡងមុនមេរៀន](https://ff-quizzes.netlify.app/en/ds/quiz/14)
|
|
|
|
|
|
|
|
អាស្រ័យលើប្រភពរបស់វា ទិន្នន័យដើមអាចមានភាពមិនសំរុងសំរួលខ្លះៗ ដែលនឹងបង្កើតឱ្យមានការលំបាកក្នុងការវិភាគ និងការបោះពុម្ពម៉ូដែល។ ថិចពាក្យផ្សេងទៀត ទិន្នន័យនេះអាចត្រូវបានចាត់ថ្នាក់ជា "បរិញ្ញ" ហើយត្រូវការប្រមូលផ្តុំឡើងវិញ។ មេរៀននេះផ្តោតលើបច្ចេកទេសសំរាប់ការសម្អាត និងបម្លែងទិន្នន័យ ដើម្បីដោះស្រាយបញ្ហាក្នុងការខ្វះខាត ទិន្នន័យមិនច្បាស់លាស់ ឬមិនពេញលេញ។ ប្រធានបទដែលបានគ្របដណ្តប់ក្នុងមេរៀននេះ នឹងប្រើប្រាស់ Python និងបណ្ណាល័យ Pandas ហើយនឹងត្រូវបាន [បង្ហាញក្នុងសៀវភៅកំណត់ត្រា](notebook.ipynb) នៅក្នុងថតនេះ។
|
|
|
|
## សារៈសំខាន់នៃការសម្អាតទិន្នន័យ
|
|
|
|
- **ភាពងាយស្រួលក្នុងការប្រើ និងប្រើឡើងវិញ**: ពេលដែលទិន្នន័យត្រូវបានរៀបចំយ៉ាងម៉ត់ចត់ និងមានការផ្ទៀងផ្ទាត់ល្អ វាធ្វើឲ្យងាយស្រួលក្នុងការស្វែងរក ប្រើប្រាស់ និងចែករំលែកជាមួយអ្នកដទៃ។
|
|
|
|
- **ភាពស៊ីទាស់**: វិទ្យាសាស្ត្រទិន្នន័យភាគច្រើនតម្រូវឲ្យធ្វើការជាមួយឈុតទិន្នន័យច្រើនជាងមួយ ដែលឈុតទិន្នន័យពីប្រភពផ្សេងៗត្រូវតែត្រូវបានភ្ជាប់ជាមួយគ្នា។ មានការត្រួតពិនិត្យថា ឈុតទិន្នន័យនីមួយៗមានស្តង់ដាររួមគ្នា នឹងធានាថាទិន្នន័យនោះនៅតែមានប្រយោជន៍ នៅពេលដែលបញ្ចូលសរុបលើឈុតទិន្នន័យតែមួយ។
|
|
|
|
- **ភាពត្រឺមត្រូវនៃម៉ូដែល**: ទិន្នន័យដែលបានសម្អាតធ្វើឲ្យមានភាពត្រឺមត្រូវជាងមុនចំពោះម៉ូដែលដែលផ្អែកលើវា។
|
|
|
|
## គោលដៅ និងយុទ្ធសាស្ត្រសម្អាតទិន្នន័យដែលត្រូវបានប្រើប្រាស់ជាទូទៅ
|
|
|
|
- **ការស្វែងយល់អំពីឈុតទិន្នន័យ**: ការស្វែងយល់ទិន្នន័យ ដែលបានរៀបរាប់នៅក្នុង [មេរៀនបន្ទាប់](https://github.com/microsoft/Data-Science-For-Beginners/tree/main/4-Data-Science-Lifecycle/15-analyzing) អាចជួយអ្នករកឃើញទិន្នន័យដែលត្រូវបានសម្អាត។ ការមើលតម្លៃក្នុងឈុតទិន្នន័យអាចបង្ហាញពីការរំពឹងទុកពីអ្វីដែលសល់នៅ ព្រមទាំងផ្តល់មួយយោបល់អំពីបញ្ហាណាដែលអាចដោះស្រាយ។ ការស្វែងយល់អាចរួមបញ្ចូលការស្វែងរកមូលដ្ឋាន ការនិម្មិត និងការរើសយកតម្លៃឯក.
|
|
|
|
- **ការប្រមូលផ្គុំទ្រង់ទ្រាយ**: អាស្រ័យលើប្រភពទិន្នន័យ អាចមានភាពមិនសមរម្យនៅក្នុងរបៀបបង្ហាញវា។ នេះអាចបង្កបញ្ហាក្នុងការស្វែងរក និងតំណាងតម្លៃ ដែលវាត្រូវបានគេឃើញនៅក្នុងឈុតទិន្នន័យ ប៉ុន្តែមិនបានតំណាងច្បាស់លាស់នៅក្នុងការបង្ហាញដូចជា និម្មិត ឬលទ្ធផលស្វែងរក។ បញ្ហាទ្រង់ទ្រាយទូទៅរួមមានការដោះស្រាយកន្លែងប្រែអាក្រាត យ៉ាងដូចជាពេលវេលា និងប្រភេទទិន្នន័យ។ ការដោះស្រាយបញ្ហាទ្រង់ទ្រាយភាគច្រើនត្រូវបានធ្វើដោយអ្នកប្រើប្រាស់ទិន្នន័យ។ ឧទាហរណ៍ ស្តង់ដារអំពីរបៀបបង្ហាញពេលវេលា និងលេខអាចខុសគ្នាតាមប្រទេស។
|
|
|
|
- **ការទទួលខុសត្រូវពីពហុចម្លង**: ទិន្នន័យដែលមានឈុតបញ្ជាក់ច្រើនជាងមួយអាចបង្កលទ្ធផលមិនត្រឹមត្រូវ ហើយភាគច្រើនត្រូវបានលុបចោល។ នេះជាបញ្ហាទូទៅនៅពេលភ្ជាប់ឈុតទិន្នន័យពីពីរឬច្រើនជាមួយគ្នា។ ទោះយ៉ាងណា មានករណីដែលការចម្លងក្នុងឈុតទិន្នន័យភ្ជាប់មានទ្រង់ទ្រាយដែលផ្តល់ព័ត៍មានបន្ថែម ហើយត្រូវការរក្សាទុក។
|
|
|
|
- **ទិន្នន័យខ្វះ**: ទិន្នន័យខ្វះអាចបង្កជាលទ្ធផលមិនត្រឹមត្រូវ និងលទ្ធផលខ្សោយ ឬមានការជម្រុញចំហ។ មួយចំនួនអាចដោះស្រាយដោយ "ផ្ទុកឡើងវិញ" ទិន្នន័យ បម្រុងតម្លៃខ្វះជាមួយកូដគណនា ដូចជា Python ឬគ្រាន់តែលុបបញ្ញត្តិ និងទិន្នន័យដដែលគ្នា។ មានមូលហេតុជាច្រើនដែលបណ្ដាលឲ្យទិន្នន័យខ្វះ ហើយសកម្មភាពបញ្ចប់ការខ្វះអាចអាស្រ័យលើរបៀប និងមូលហេតុដែលវាបាត់បង់។
|
|
|
|
## ស្វែងរកព័ត៌មាន DataFrame
|
|
> **គោលដៅសិក្សា:** នៅចុងផ្នែកនេះ អ្នកគួរតែមានភាពរលូនក្នុងការស្វែងរកព័ត៌មានទូទៅអំពីទិន្នន័យដែលបានផ្ទុកនៅក្នុង pandas DataFrames។
|
|
|
|
ពេលដែលអ្នកបានផ្ទុកទិន្នន័យរបស់អ្នកទៅ pandas វាធម្មតាបង្ហាញក្នុងរូបបែប DataFrame (សូមយោងទៅមេរៀនមុន [នេះ](https://github.com/microsoft/Data-Science-For-Beginners/tree/main/2-Working-With-Data/07-python#dataframe) សម្រាប់ការពិពណ៌នាអំពីរូបមន្តពិសេស)។ ប៉ុន្តែបើសិនជាឈុតទិន្នន័យក្នុង DataFrame របស់អ្នកមានជួរដេក 60,000 និងជួរឈរ 400 ចេញវិញ តើអ្នកចាប់ផ្តើមយ៉ាងដូចម្តេចដើម្បីយល់ពីអ្វីដែលអ្នកកំពុងរក្សា? ករណីសំណាងមួយគឺ [pandas](https://pandas.pydata.org/) ផ្តល់ឧបករណ៍ងាយស្រួលមួយចំនួនក្នុងការមើលព័ត៌មានទាំងមូលអំពី DataFrame បូកនឹងបន្ទាត់ដើម និងបន្ទាត់ចុងក្រោយពីរបីជួរ។
|
|
|
|
ដើម្បីសាកល្បងមើលមុខងារ នេះ យើងនឹងនាំចូលបណ្ណាល័យ Python scikit-learn ហើយប្រើឈុតទិន្នន័យដ៏ល្បី: **ឈុតទិន្នន័យ Iris**។
|
|
|
|
```python
|
|
import pandas as pd
|
|
from sklearn.datasets import load_iris
|
|
|
|
iris = load_iris()
|
|
iris_df = pd.DataFrame(data=iris['data'], columns=iris['feature_names'])
|
|
```
|
|
| |sepal length (cm)|sepal width (cm)|petal length (cm)|petal width (cm)|
|
|
|----------------------------------------|-----------------|----------------|-----------------|----------------|
|
|
|0 |5.1 |3.5 |1.4 |0.2 |
|
|
|1 |4.9 |3.0 |1.4 |0.2 |
|
|
|2 |4.7 |3.2 |1.3 |0.2 |
|
|
|3 |4.6 |3.1 |1.5 |0.2 |
|
|
|4 |5.0 |3.6 |1.4 |0.2 |
|
|
|
|
- **DataFrame.info**: ដើម្បីចាប់ផ្តើម វិធីសាស្ត្រ `info()` ត្រូវបានប្រើសម្រាប់បោះពុម្ពសេចក្តីសង្ខេបពីមាតិកាដែលមានក្នុង `DataFrame`។ យើងសូមមើលឈុតទិន្នន័យនេះដើម្បីមើលអ្វីដែលយើងមាន៖
|
|
```python
|
|
iris_df.info()
|
|
```
|
|
```
|
|
RangeIndex: 150 entries, 0 to 149
|
|
Data columns (total 4 columns):
|
|
# Column Non-Null Count Dtype
|
|
--- ------ -------------- -----
|
|
0 sepal length (cm) 150 non-null float64
|
|
1 sepal width (cm) 150 non-null float64
|
|
2 petal length (cm) 150 non-null float64
|
|
3 petal width (cm) 150 non-null float64
|
|
dtypes: float64(4)
|
|
memory usage: 4.8 KB
|
|
```
|
|
ពីនេះ យើងដឹងថា ឈុតទិន្នន័យ *Iris* មានការចុះបញ្ជី 150 ក្នុងជួរឈរ 4 ដោយគ្មានការចុះបញ្ជីណាមួយដែលទទេ។ ទិន្នន័យទាំងអស់ត្រូវបានផ្ទុកជាលេខចត់ខ្សែកោណ 64 ប៊ីត។
|
|
|
|
- **DataFrame.head()**: បន្ទាប់មក ដើម្បីពិនិត្យមើលមាតិកានៃ `DataFrame` យើងប្រើវិធីសាស្ត្រ `head()`។ មកមើលជួរដេកដំបូងៗរបស់ `iris_df`៖
|
|
```python
|
|
iris_df.head()
|
|
```
|
|
```
|
|
sepal length (cm) sepal width (cm) petal length (cm) petal width (cm)
|
|
0 5.1 3.5 1.4 0.2
|
|
1 4.9 3.0 1.4 0.2
|
|
2 4.7 3.2 1.3 0.2
|
|
3 4.6 3.1 1.5 0.2
|
|
4 5.0 3.6 1.4 0.2
|
|
```
|
|
- **DataFrame.tail()**: ក្នុងវិញវិញត្រូវការ ពិនិត្យមើលជួរដេកចុងក្រោយនៃ `DataFrame` យើងប្រើវិធីសាស្ត្រ `tail()`៖
|
|
```python
|
|
iris_df.tail()
|
|
```
|
|
```
|
|
sepal length (cm) sepal width (cm) petal length (cm) petal width (cm)
|
|
145 6.7 3.0 5.2 2.3
|
|
146 6.3 2.5 5.0 1.9
|
|
147 6.5 3.0 5.2 2.0
|
|
148 6.2 3.4 5.4 2.3
|
|
149 5.9 3.0 5.1 1.8
|
|
```
|
|
> **ការសង្ខេប**៖ ត្រឹមតែការមើលលម្អិតព័ត៌មានអំពីមាតិកានៅក្នុង DataFrame ឬតម្លៃដំបូងនិងចុងក្រោយ អ្នកអាចទទួលបានគំនិតមួយភ្លាមភ្លើយនៃទំហំ រាងរូប និងមាតិកានៃទិន្នន័យដែលអ្នកកំពុងដោះស្រាយ។
|
|
|
|
## ជួបប្រទៈនឹងទិន្នន័យខ្វះ
|
|
> **គោលដៅសិក្សា:** នៅចុងផ្នែកនេះ អ្នកគួរតែដឹងរបៀបជំនួស ឬដកចេញតម្លៃទទេពី DataFrames។
|
|
|
|
ភាគច្រើនពេលឈុតទិន្នន័យដែលអ្នកចង់ប្រើ ឬត្រូវប្រើ មានតម្លៃខ្វះនៅក្នុងវា។ របៀបដំណើរការទិន្នន័យខ្វះ មានការជួញដូរលំបាកដែលអាចប៉ះពាល់ទៅលើការវិភាគចុងក្រោយ និងលទ្ធផលពិតប្រាកដ។
|
|
|
|
Pandas ដំណើរការតម្លៃខ្វះពីរបៀប។ មួយដែលអ្នកបានឃើញនៅផ្នែកមុនគឺ `NaN` ឬ Not a Number។ នេះជាតម្លៃពិសេសមួយដែលជាផ្នែកនៃលក្ខណៈ IEEE ចត់ខ្សែកោណ ហើយត្រូវបានប្រើសម្រាប់បង្ហាញតម្លៃចត់ខ្សែកោណដែលខ្វះតែប៉ុណ្ណោះ។
|
|
|
|
សម្រាប់តម្លៃខ្វះដែលមិនមែនជាចត់ខ្សែកោណ pandas ប្រើអ объекта Python `None`។ ខណៈដែលវាអាចមានភាពស្មុគស្មាញថាអ្នកនឹងជួបប្រទៈតម្លៃពីប្រាំបីប្រភេទផ្សេងគ្នាដែលមានន័យដូចគ្នា តែមានហេតុផលកម្មវិធីដ៏ច្បាស់លាស់សម្រាប់ការរចនាតាមរយៈនេះ ហើយក្នុងអនុវត្ត វាជួយឲ្យ pandas ផ្តល់កំណត់សមស្របល្អសម្រាប់ករណីភាគច្រើន។ ទោះយ៉ាងណា ទាំង `None` និង `NaN` មានកំណត់ខ្លះៗ ដែលអ្នកត្រូវយកចិត្តទុកដាក់ទាក់ទងមានករណីអាចប្រើប្រាស់បាន។
|
|
|
|
សូមមើលបន្ថែមអំពី `NaN` និង `None` ពី [សៀវភៅកំណត់ត្រា](https://github.com/microsoft/Data-Science-For-Beginners/blob/main/4-Data-Science-Lifecycle/15-analyzing/notebook.ipynb)។
|
|
|
|
- **ការរកឃើញតម្លៃទទេ**: ក្នុង `pandas` វិធីសាស្ត្រ `isnull()` និង `notnull()` ជាវិធីសាស្ត្រដែលអ្នកប្រើសម្រាប់រកឃើញទិន្នន័យទទេ។ ទាំងពីរត្រឡប់ជាផ្ទាំងបឹនទិន្នន័យ Boolean នៅលើទិន្នន័យរបស់អ្នក។ យើងនឹងប្រើ `numpy` សម្រាប់តម្លៃ `NaN`:
|
|
```python
|
|
import numpy as np
|
|
|
|
example1 = pd.Series([0, np.nan, '', None])
|
|
example1.isnull()
|
|
```
|
|
```
|
|
0 False
|
|
1 True
|
|
2 False
|
|
3 True
|
|
dtype: bool
|
|
```
|
|
មើលយ៉ាងម៉ត់ចត់លទ្ធផល។ តើមានអ្វីដែលធ្វើឲ្យអ្នកភ្ញាក់ផ្អើលទេ? ខណៈ `0` គឺជាចំនួនសូន្យសម្រាប់គណិតវិទ្យា ប៉ុន្តែវាគឺជាចំនួនគត់ដែលមានតម្លៃត្រឹមត្រូវ ហើយ pandas ទទួលស្គាល់វា។ `''` (ខ្សែអក្សរពុំមានអ្វី) ពិបាកច្រើនជាង។ នៅផ្នែកមុនយើងបានប្រើវាសម្រាប់តំណាងតម្លៃខ្សែអក្សរដែលទទេ ប៉ុន្តែវាក៏ជាវត្ថុខ្សែអក្សរប្រើ និងមិនមែនតំណាងនៃតម្លៃទទេដូចជាកម្មវិធី pandas។
|
|
|
|
ឥឡូវនេះ ប្រើវាផ្ទៃមុខវិញ ខណៈនេះ អ្នកអាចប្រើផ្ទាំងបឹន Boolean ដូចជា ``Series`` ឬ ``DataFrame`` index ដោយផ្ទាល់ ដែលអាចមានប្រយោជន៍ពេលចង់ធ្វើការជាមួយតម្លៃខ្វះឯកាស (ឬតម្លៃមាន) ។
|
|
|
|
> **ការសង្ខេប**៖ ទាំងវិធីសាស្ត្រ `isnull()` និង `notnull()` ផ្តល់លទ្ធផលស្រដៀងគ្នាពេលអ្នកប្រើវានៅក្នុង `DataFrame`s៖ វាបង្ហាញលទ្ធផល និងតំណរភ្ជាប់របស់លទ្ធផល ពោលគឺជាឧបករណ៍ជួយដល់អ្នកយ៉ាងខ្លាំងក្នុងការគ្រប់គ្រងទិន្នន័យរបស់អ្នក។
|
|
|
|
- **ការលុបទិន្នន័យទទេ**: លើសពីការចាប់ផ្តើមរកតម្លៃខ្វះ pandas ផ្តល់វិធីងាយស្រួលមួយសម្រាប់លុបទិន្នន័យទទេពី `Series` និង `DataFrame`s។ (សម្រាប់ឈុតទិន្នន័យធំៗ ជាច្រើនពេល ល្អប្រសើរជាងក្នុងការលុបតម្លៃទទេ [NA] ពីការវិភាគរបស់អ្នកជាជម្រើសជាងវិធីផ្សេងៗ)។ ដើម្បីឃើញវាដំណើរការ ចុចត្រឡប់ទៅ `example1`:
|
|
```python
|
|
example1 = example1.dropna()
|
|
example1
|
|
```
|
|
```
|
|
0 0
|
|
2
|
|
dtype: object
|
|
```
|
|
សូមចងចាំថា វានឹងដូចជាលទ្ធផលរបស់អ្នកពី `example3[example3.notnull()]`។ ខុសគ្នាគឺ `dropna` បានលុបទិន្នន័យខ្វះនៅក្នុង `Series` `example1` រួច។
|
|
|
|
ដោយសារតែ `DataFrame`s មានទំហំពីរ វាអនុញ្ញាតឱ្យមានជម្រើសច្រើនសម្រាប់ការលុបទិន្នន័យ។
|
|
|
|
```python
|
|
example2 = pd.DataFrame([[1, np.nan, 7],
|
|
[2, 5, 8],
|
|
[np.nan, 6, 9]])
|
|
example2
|
|
```
|
|
| | 0 | 1 | 2 |
|
|
|------|---|---|---|
|
|
|0 |1.0|NaN|7 |
|
|
|1 |2.0|5.0|8 |
|
|
|2 |NaN|6.0|9 |
|
|
|
|
(តើអ្នកមើលឃើញទេថា pandas បានបំលែងជួរឈរពីរចំនួនមួយទៅជាចត់ខ្សែកោណ ដើម្បីផ្តល់គម្លាតទៅ `NaN`s?)
|
|
|
|
អ្នកមិនអាចលុបទតម្លៃតែមួយនៅក្នុង `DataFrame` បានទេ អ្នកត្រូវលុបជួរដេកឬជួរឈរ។ អាស្រ័យលើអ្វីដែលអ្នកកំពុងធ្វើ អ្នកអាចចង់ធ្វើមួយក្នុងពីរប្រភេទ ហើយ pandas ផ្ដល់ជម្រើសទាំងពីរឱ្យអ្នក។ ពីព្រោះនៅវិទ្យាសាស្រ្តទិន្នន័យ ជួរឈរបង្ហាញអថេរ ហើយជួរដេកបង្ហាញការសង្កេតមើល ខណៈលំនាំដើមសម្រាប់ `dropna()` គឺលុបជួរដេកទាំងអស់ដែលមានតម្លៃទទេណាមួយ៖
|
|
|
|
```python
|
|
example2.dropna()
|
|
```
|
|
```
|
|
0 1 2
|
|
1 2.0 5.0 8
|
|
```
|
|
បើតម្រូវ អ្នកអាចលុបទម្លៃ NA ពីជួរឈរ។ ប្រើ `axis=1` ដើម្បីធ្វើវា:
|
|
```python
|
|
example2.dropna(axis='columns')
|
|
```
|
|
```
|
|
2
|
|
0 7
|
|
1 8
|
|
2 9
|
|
```
|
|
ចាប់តាំងពីនេះ អ្នកអាចលុបទិន្នន័យច្រើនដែលអ្នកចង់រក្សាទុក ជាពិសេសសម្រាប់ឈុតទិន្នន័យតូចៗ។ ដូចម្តេចបើអ្នកចង់លុបតែជួរដេក ឬជួរឈរដែលមានតម្លៃទទេជាច្រើន ឬគ្រប់តែអស់? អ្នកអាចកំណត់ជម្រើសនោះនៅក្នុង `dropna` ជាមួយប៉ារ៉ាម៉ែត្រ `how` និង `thresh`។
|
|
|
|
លំនាំដើម របស់ `how='any'` (បើអ្នកចង់ពិនិត្យផ្ទាល់ ឬមើលប៉ារ៉ាម៉ែត្រផ្សេងៗរបស់វិធីសាស្ត្រ អាចបញ្ចូល `example4.dropna?` ក្នុងកោដទ័រ)។ យើងអាចកំណត់ជំរឿន `how='all'` ដើម្បីលុបតែកំណត់តែជួរដេក ឬជួរឈរដែលមានតម្លៃទទេគ្រប់អស់ប៉ុណ្ណោះ។ យើងពង្រីកឧទាហរណ៍ `DataFrame` ដើម្បីមើលវាដំណើរការ។
|
|
|
|
```python
|
|
example2[3] = np.nan
|
|
example2
|
|
```
|
|
| |0 |1 |2 |3 |
|
|
|------|---|---|---|---|
|
|
|0 |1.0|NaN|7 |NaN|
|
|
|1 |2.0|5.0|8 |NaN|
|
|
|2 |NaN|6.0|9 |NaN|
|
|
|
|
ប៉ារ៉ាម៉ែត្រ `thresh` ផ្តល់ការគ្រប់គ្រងលំអិតជាង៖ អ្នកកំណត់ចំនួនតម្លៃ *មិនទទេ* ដែលជួរដេក ឬជួរឈរត្រូវមាន ដើម្បីរក្សាទុកវា:
|
|
```python
|
|
example2.dropna(axis='rows', thresh=3)
|
|
```
|
|
```
|
|
0 1 2 3
|
|
1 2.0 5.0 8 NaN
|
|
```
|
|
នៅទីនេះ ជួរដេកដំបូង និងចុងក្រោយ ត្រូវបានលុបចេញ ដោយសារតែវាមានត្រឹមតែលេខមិនទទេពីរតែប៉ុណ្ណោះ។
|
|
|
|
- **បំពេញតម្លៃទទេ**: អាស្រ័យលើឈុតទិន្នន័យរបស់អ្នក ផ្លាស់ប្តូរតម្លៃទទេទៅតម្លៃត្រឹមត្រូវអាចមានអត្ថិភាពជាងការលុបវា។ អ្នកអាចប្រើ `isnull` ដើម្បីធ្វើការនេះនៅកន្លែងដដែល ប៉ុន្តែវាអាចលំបាកជាពិសេសបើអ្នកមានតម្លៃជាច្រើនត្រូវបំពេញ។ ព្រោះនេះជាការងារសំខាន់មួយក្នុងវិទ្យាសាស្រ្តទិន្នន័យ pandas ផ្ដល់ `fillna` ដែលបង្វិលតម្លៃ `Series` ឬ `DataFrame` ជាមួយតម្លៃថ្មីដែលអ្នកជ្រើសរើស។ យើងបង្កើត `Series` ឧទាហរណ៍មួយទៀតដើម្បីមើលរបៀបនេះដំណើរការ។
|
|
|
|
```python
|
|
example3 = pd.Series([1, np.nan, 2, None, 3], index=list('abcde'))
|
|
example3
|
|
```
|
|
```
|
|
a 1.0
|
|
b NaN
|
|
c 2.0
|
|
d NaN
|
|
e 3.0
|
|
dtype: float64
|
|
```
|
|
អ្នកអាចបំពេញតម្លៃទទេទាំងអស់ជាមួយតម្លៃតែមួយដូចជា `0`៖
|
|
```python
|
|
example3.fillna(0)
|
|
```
|
|
```
|
|
a 1.0
|
|
b 0.0
|
|
c 2.0
|
|
d 0.0
|
|
e 3.0
|
|
dtype: float64
|
|
```
|
|
អ្នកអាច **បំពេញជាដំណាក់កាលមុខ** ត្រូវគឺប្រើតម្លៃត្រឹមត្រូវចុងក្រោយសម្រាប់បំពេញតម្លៃទទេ៖
|
|
```python
|
|
example3.fillna(method='ffill')
|
|
```
|
|
```
|
|
a 1.0
|
|
b 1.0
|
|
c 2.0
|
|
d 2.0
|
|
e 3.0
|
|
dtype: float64
|
|
```
|
|
អ្នកអាច **បំពេញបិទក្រោយ** ដើម្បីបញ្ជូនតម្លៃត្រឹមត្រូវបន្ទាប់ទៅបំពេញតម្លៃទទេ៖
|
|
```python
|
|
example3.fillna(method='bfill')
|
|
```
|
|
```
|
|
a 1.0
|
|
b 2.0
|
|
c 2.0
|
|
d 3.0
|
|
e 3.0
|
|
dtype: float64
|
|
```
|
|
ដូចអ្នកអាចយល់បាន វាដំណើរការដូចគ្នាជាមួយ `DataFrame`s ហើយអ្នកអាចកំណត់ `axis` សម្រាប់បំពេញតម្លៃទទេក៏បាន។ យក `example2` ដែលបានប្រើជាមុនវិញ៖
|
|
```python
|
|
example2.fillna(method='ffill', axis=1)
|
|
```
|
|
```
|
|
0 1 2 3
|
|
0 1.0 1.0 7.0 7.0
|
|
1 2.0 5.0 8.0 8.0
|
|
2 NaN 6.0 9.0 9.0
|
|
```
|
|
សូមចំណាំថា ពេលមិនមានតម្លៃត្រឹមត្រូវពីមុនសម្រាប់បំពេញជាដំណាក់កាលមុខ តម្លៃទទេនៅតែស្ថិតនៅដដែល។
|
|
> **takeaway៖** មានវិធីជាច្រើនក្នុងការដោះស្រាយគុណតម្លៃដែលខ្វះនៅក្នុងឯកសារទិន្នន័យរបស់អ្នក។ ច្បាស់លាស់ នយោបាយជាក់លាក់ដែលអ្នកប្រើ (ការដកចេញ, ការជំនួស, ឬរបៀបដែលអ្នកជំនួស) ត្រូវតែត្រូវបានគ្រប់គ្រងដោយលក្ខខណ្ឌជាក់លាក់នៃទិន្នន័យនោះ។ អ្នកនឹងអភិវឌ្ឍអារម្មណ៍ល្អប្រសើរជាងមុនក្នុងការដោះស្រាយគុណតម្លៃដែលខ្វះដោយថែមទាំងអ្នកដំណើរការ និងអន្តរកម្មជាមួយឯកសារទិន្នន័យ។
|
|
|
|
## ការដកចេញទិន្នន័យចម្លង
|
|
|
|
> **គោលបំណងរៀន៖** នៅចុងផ្នែកនេះ អ្នកគួរតែធ្វើការរកមើល និងដកចេញគុណតម្លៃចម្លងពី DataFrames បានយ៉ាងងាយស្រួល។
|
|
|
|
ក្រៅពីទិន្នន័យដែលខ្វះ អ្នកគេជាញឹកញាប់ជួបប្រទៈទិន្នន័យចម្លងក្នុងឯកសារទិន្នន័យជាក់ស្តែង។ សំណាងល្អ `pandas` ផ្តល់នូវវិធីងាយស្រួលក្នុងការរកឃើញ និងដកចេញធាតុចម្លង។
|
|
|
|
- **ការរកមើលចម្លង៖ `duplicated`**៖ អ្នកអាចរកមើលគុណតម្លៃចម្លងបានយ៉ាងងាយដោយប្រើវិធីសាស្រ្ត `duplicated` នៅក្នុង pandas ដែលបញ្ជូនត្រឡប់ពីម៉ាស Boolean បង្ហាញថាប្រសិនបើធាតុនៅក្នុង `DataFrame` ជាចម្លងនៃធាតុមួយដែលមុនហើយ។ យើងនឹងបង្កើត `DataFrame` គំរូមួយទៀតដើម្បីមើលវាកំពុងបង្ហាញដូចម្តេច។
|
|
```python
|
|
example4 = pd.DataFrame({'letters': ['A','B'] * 2 + ['B'],
|
|
'numbers': [1, 2, 1, 3, 3]})
|
|
example4
|
|
```
|
|
| |letters|numbers|
|
|
|------|-------|-------|
|
|
|0 |A |1 |
|
|
|1 |B |2 |
|
|
|2 |A |1 |
|
|
|3 |B |3 |
|
|
|4 |B |3 |
|
|
|
|
```python
|
|
example4.duplicated()
|
|
```
|
|
```
|
|
0 False
|
|
1 False
|
|
2 True
|
|
3 False
|
|
4 True
|
|
dtype: bool
|
|
```
|
|
- **ការដកចេញចម្លង៖ `drop_duplicates`:** គ្រាន់តែត្រឡប់មកជាការចម្លងនៃទិន្នន័យដែលសម្រាប់វាល `duplicated` ទាំងអស់គឺ `False`:
|
|
```python
|
|
example4.drop_duplicates()
|
|
```
|
|
```
|
|
letters numbers
|
|
0 A 1
|
|
1 B 2
|
|
3 B 3
|
|
```
|
|
ទាំង `duplicated` និង `drop_duplicates` ធម្មតាជ្រើសរើសពិនិត្យគ្រប់ជួរឈរប៉ុន្តែអ្នកអាចកំណត់ឲ្យពិនិត្យតែខ្សែជួរឈរមួយចំនួននៅក្នុង `DataFrame` របស់អ្នកបាន:
|
|
```python
|
|
example4.drop_duplicates(['letters'])
|
|
```
|
|
```
|
|
letters numbers
|
|
0 A 1
|
|
1 B 2
|
|
```
|
|
|
|
> **takeaway៖** ការដកចេញទិន្នន័យចម្លងគឺជាផ្នែកសំខាន់នៃគម្រោងវិទ្យាសាស្ត្រទិន្នន័យរាល់គម្រោងជិតទាំងអស់។ ទិន្នន័យចម្លងអាចប្ដូរលទ្ធផលនៃការវិភាគរបស់អ្នក និងផ្តល់លទ្ធផលមិនត្រឹមត្រូវ!
|
|
|
|
## 🚀 ប្រកួតប្រជែង
|
|
|
|
សម្ភារៈទាំងអស់ដែលបានពិភាក្សាត្រូវបានផ្តល់ជាទំព័រជា [Jupyter Notebook](https://github.com/microsoft/Data-Science-For-Beginners/blob/main/2-Working-With-Data/08-data-preparation/notebook.ipynb)។ លើសពីនេះ សូមពិនិត្យមើលលំហាត់កីឡា ក្រោយផ្នែកនីមួយៗ បញ្ជាក់សូមសាកល្បង!
|
|
|
|
## [តេស្តបន្ទាប់មកពីការបង្រៀន](https://ff-quizzes.netlify.app/en/ds/quiz/15)
|
|
|
|
|
|
|
|
## ពិនិត្យឡើងវិញ និងសិក្សាដោយខ្លួនឯង
|
|
|
|
មានវិធីជាច្រើនក្នុងការស្វែងរក និងប្រើប្រាស់ដើម្បីរៀបចំទិន្នន័យរបស់អ្នកសម្រាប់ការវិភាគ និងគំរូ និងការសម្អាតទិន្នន័យគឺជជំហានសំខាន់ដែលជាបទពិសោធ "ដៃលើ"។ សាកល្បងកម្មវិធីប្រកួតប្រជែងទាំងនេះពី Kaggle ដើម្បីស្រាវជ្រាវបច្ចេកទេសដែលមេរៀននេះមិនបានគ្រប់គ្រាន់។
|
|
|
|
- [ភាពប្រកួតប្រជែងសម្អាតទិន្នន័យ៖ ការបំលែងកាលបរិច្ឆេទ](https://www.kaggle.com/rtatman/data-cleaning-challenge-parsing-dates/)
|
|
|
|
- [ភាពប្រកួតប្រជែងសម្អាតទិន្នន័យ៖ ការវាស់ស័យ និងការប្រកួតទិន្នន័យ](https://www.kaggle.com/rtatman/data-cleaning-challenge-scale-and-normalize-data)
|
|
|
|
|
|
## ការប្រឡង
|
|
|
|
[ការវាយតម្លៃទិន្នន័យពីបែបបទ](assignment.md)
|
|
|
|
---
|
|
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
|
|
**ការបដិសេធ**៖
|
|
ឯកសារនេះបានបកប្រែដោយប្រើសេវាកម្មបកប្រែ AI [Co-op Translator](https://github.com/Azure/co-op-translator)។ ខណៈពេលដែលយើងខំប្រឹងប្រែងដើម្បីឲ្យបានភាពត្រឹមត្រូវ សូមយល់ថាការបកប្រែដោយស្វ័យប្រវត្តិអាចមានកំហុស ឬខុសប្លែកខ្លះៗបាន។ ឯកសារដើមក្នុងភាសាដើមគួរត្រូវបានដឹងថាជាធនធានផ្លូវការដោយផ្ទាល់។ សម្រាប់ព័ត៌មានសំខាន់ៗ សូមលើកទឹកចិត្តឲ្យមានការបកប្រែដោយអ្នកជំនាញមនុស្ស។ យើងមិនទទួលខុសត្រូវចំពោះការយល់ច្រឡំ ឬការបកស្រាយខុសណាមួយបណ្តាលមកពីការប្រើប្រាស់បកប្រែនេះឡើយ។
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER END --> |