Data Cleaning

การทำ Data Cleaning คืออะไร

การทำ Data Cleaning คือการเตรียมและปรับปรุงข้อมูลให้อยู่ในรูปแบบที่พร้อมสำหรับการวิเคราะห์หรือใช้งานต่อไป โดยการทำ Data Cleaning จะช่วยกำจัดข้อมูลที่ไม่สมบูรณ์ ไม่ถูกต้อง หรือซ้ำซ้อน ซึ่งมักเกิดจากข้อผิดพลาดในการเก็บข้อมูลหรือจากแหล่งข้อมูลที่หลากหลาย

โดยใน Python มีเครื่องมือหลายอย่างที่ใช้ในการทำ Data Cleaning เช่น:

1. การตรวจหาค่า Missing Values: ตรวจสอบหาค่าที่ขาดหาย และจัดการกับค่าเหล่านี้ เช่น การแทนที่ด้วยค่าเฉลี่ย (mean), ค่ามัธยฐาน (median) หรือการลบแถวที่มีค่า Missing

df.dropna()  # ลบแถวที่มีค่าว่าง
df.fillna(value)  # แทนค่าที่ขาดหายด้วยค่าอื่น

2. การลบหรือแทนค่าที่ซ้ำซ้อน: ค่าที่ซ้ำอาจทำให้การวิเคราะห์ข้อมูลผิดเพี้ยนได้ สามารถใช้ drop_duplicates() เพื่อลบค่าที่ซ้ำ
3. การจัดการกับข้อมูลที่ผิดรูปแบบหรือ outliers: ข้อมูลที่ไม่ตรงตามรูปแบบที่ต้องการ หรือค่าที่สูงหรือต่ำผิดปกติ ควรตรวจสอบและแก้ไขเพื่อความแม่นยำในการวิเคราะห์
4. การเปลี่ยนประเภทข้อมูล (Data Type Conversion): เปลี่ยนประเภทข้อมูลให้เหมาะสม เช่น เปลี่ยนจาก object เป็น datetime

df['date_column'] = pd.to_datetime(df['date_column'])

5. การปรับแต่งข้อมูลตามรูปแบบที่ต้องการ: เช่น การทำให้ตัวอักษรเป็นตัวพิมพ์เล็ก/ใหญ่, การแยกหรือรวมคอลัมน์, และการจัดการกับข้อมูลที่เป็นข้อความ

เราจะมาลองเจาะลึกในการจัดการแต่ละรูปแบบกัน

Missing Values

Missing Values หมายถึงข้อมูลที่ขาดหายไปหรือไม่ได้รับการบันทึก ซึ่งส่งผลให้เกิดช่องว่างในชุดข้อมูล การมี Missing Values เป็นเรื่องปกติเมื่อทำงานกับข้อมูลจากแหล่งต่าง ๆ เช่น การเก็บข้อมูลจากแบบสอบถามที่บางคนอาจไม่ตอบทุกคำถาม หรือจากระบบที่มีข้อผิดพลาดในการบันทึกข้อมูล

การจัดการกับ Missing Values เป็นสิ่งสำคัญในการทำ Data Cleaning เนื่องจากการวิเคราะห์ข้อมูลที่มี Missing Values อาจทำให้ผลลัพธ์ผิดเพี้ยนได้

โดย การจัดการกับ Missing Values ด้วย Python เรามักใช้ Pandas ในการจัดการข้อมูลและตรวจสอบ Missing Values โดยมีวิธีการหลัก ๆ ดังนี้ สมมุติว่าเรามี Data หน้าตาแบบนี้

import pandas as pd
import numpy as np

# สร้าง DataFrame ตัวอย่างที่มี Missing Values
data = {
    'name': ['Alice', 'Bob', 'Charlie', 'David', np.nan],
    'age': [24, np.nan, 22, 29, 31],
    'salary': [50000, 54000, np.nan, np.nan, 59000]
}

df = pd.DataFrame(data)
print("Original Data:")
print(df)

และได้ Dataframe แบบนี้ออกมา

Original Data:
      name   age   salary
0    Alice  24.0  50000.0
1      Bob   NaN  54000.0
2  Charlie  22.0      NaN
3    David  29.0      NaN
4      NaN  31.0  59000.0

โดยคำสั่งหลักๆที่เรามักจะใช้ตรวจสอบเรื่อง Missing Values จะมีประมาณนี้

1. ตรวจสอบ Missing Value: การตรวจสอบเพื่อดูว่า Missing Values อยู่ที่ตำแหน่งไหนในข้อมูลของเรา โดยใช้ .isnull() และ .sum()

print("\nตรวจสอบ Missing Values:")
print(df.isnull())  # แสดง True/False หากข้อมูลนั้นๆ เป็นค่าว่าง
print("\nจำนวน Missing Values ในแต่ละคอลัมน์:")
print(df.isnull().sum())  # นับจำนวน Missing Values ในแต่ละคอลัมน์

2. ลบแถวที่มี Missing Values (Dropping Rows)

ใช้ .dropna() เพื่อลบแถวที่มี Missing Values ออกทั้งหมด

# ลบแถวที่มี Missing Values
df_dropped = df.dropna()
print("\nหลังจากลบแถวที่มี Missing Values:")
print(df_dropped)

ผลลัพธ์

หลังจากลบแถวที่มี Missing Values:
    name   age   salary
0  Alice  24.0  50000.0

3. แทนที่ Missing Values ด้วยค่าเฉลี่ยหรือค่ากลาง (Filling with Mean or Median)

ใช้ .fillna() เพื่อลงค่าทดแทน เช่น ค่าเฉลี่ยหรือค่ากลาง ในกรณีที่คอลัมน์นั้นเป็นตัวเลข

# แทนที่ Missing Values ในคอลัมน์ 'age' ด้วยค่าเฉลี่ย
df['age'] = df['age'].fillna(df['age'].mean())
print("\nหลังจากแทนที่ Missing Values ในคอลัมน์ 'age' ด้วยค่าเฉลี่ย:")
print(df)

# แทนที่ Missing Values ในคอลัมน์ 'salary' ด้วยค่ากลาง
df['salary'] = df['salary'].fillna(df['salary'].median())
print("\nหลังจากแทนที่ Missing Values ในคอลัมน์ 'salary' ด้วยค่ากลาง:")
print(df)

ผลลัพธ์

หลังจากแทนที่ Missing Values ในคอลัมน์ 'age' ด้วยค่าเฉลี่ย:
      name   age   salary
0    Alice  24.0  50000.0
1      Bob  26.5  54000.0
2  Charlie  22.0      NaN
3    David  29.0      NaN
4      NaN  31.0  59000.0

หลังจากแทนที่ Missing Values ในคอลัมน์ 'salary' ด้วยค่ากลาง:
      name   age   salary
0    Alice  24.0  50000.0
1      Bob  26.5  54000.0
2  Charlie  22.0  54000.0
3    David  29.0  54000.0
4      NaN  31.0  59000.0

4. แทนที่ Missing Values ด้วยค่าที่พบบ่อยที่สุด (Filling with Mode)

# แทนที่ Missing Values ในคอลัมน์ 'name' ด้วยค่าที่พบบ่อยที่สุด
df['name'] = df['name'].fillna(df['name'].mode()[0])
print("\nหลังจากแทนที่ Missing Values ในคอลัมน์ 'name' ด้วยค่าที่พบบ่อยที่สุด:")
print(df)

5. ใช้วิธี Interpolation

Interpolation คือวิธีการคำนวณหาค่าข้อมูลที่ขาดหายไปโดยประมาณจากค่าข้อมูลที่มีอยู่ วิธีนี้มักใช้ในการประเมินหรือคาดการณ์ค่าข้อมูลที่อยู่ระหว่างค่าที่มีอยู่แล้ว โดยเฉพาะข้อมูลที่เป็นลำดับเวลา (Time Series) หรือข้อมูลเชิงตัวเลขที่มีการเรียงลำดับอย่างต่อเนื่อง การใช้ Interpolation จะช่วยให้ชุดข้อมูลมีความสมบูรณ์มากขึ้นโดยที่ค่าที่เติมเข้าไปยังคงสอดคล้องกับแนวโน้มเดิม เช่น ราคาหุ้น, อุณหภูมิรายชั่วโมง หรือ ใช้เติมข้อมูลใน Dataset ทั่วไปที่มี NaN เพื่อให้สามารถวิเคราะห์หรือสร้างโมเดล Machine Learning ได้ง่ายขึ้น

https://study.com/academy/lesson/interpolation-in-statistics-definition-formula-example.html

Interpolation ใช้ในการประมาณค่าตัวเลขที่ขาดหายไปในข้อมูลเชิงตัวเลข เช่น ข้อมูลเวลา หรือข้อมูลลำดับต่อเนื่อง

# แทนที่ Missing Values ในคอลัมน์ 'age' ด้วย Interpolation
df['age'] = df['age'].interpolate()
print("\nหลังจากแทนที่ Missing Values ในคอลัมน์ 'age' ด้วย Interpolation:")
print(df)

ผลลัพธ์

หลังจากแทนที่ Missing Values ในคอลัมน์ 'age' ด้วย Interpolation:
      name   age   salary
0    Alice  24.0  50000.0
1      Bob  26.5  54000.0
2  Charlie  22.0  54000.0
3    David  29.0  54000.0
4      NaN  31.0  59000.0

1. การเติม Missing Values ตามข้อมูลก่อนหน้า/หลังหน้า (Forward Fill / Backward Fill)

การเติมค่าตามข้อมูลก่อนหน้า (Forward Fill) หรือถอยหลัง (Backward Fill) จะช่วยรักษาความต่อเนื่องของข้อมูล เช่น ข้อมูลที่เป็นลำดับเหตุการณ์หรือข้อมูลรายวัน

# เติมค่าตามข้อมูลก่อนหน้า (Forward Fill)
df_ffill = df.fillna(method='ffill')
print("\nหลังจากเติมค่าตามข้อมูลก่อนหน้า (Forward Fill):")
print(df_ffill)

# เติมค่าตามข้อมูลหลังหน้า (Backward Fill)
df_bfill = df.fillna(method='bfill')
print("\nหลังจากเติมค่าตามข้อมูลหลังหน้า (Backward Fill):")
print(df_bfill)

เป็นต้น

เป้าหมายของการจัดการ Missing Values คือการทำให้ข้อมูลมีความสมบูรณ์มากขึ้น เพื่อให้สามารถนำไปใช้ในการวิเคราะห์และสร้าง Model ได้อย่างมีประสิทธิภาพและแม่นยำ การที่ข้อมูลขาดหายไปอาจทำให้ผลการวิเคราะห์มีความผิดพลาดหรือลดประสิทธิภาพของ model Machine Learning ได้ ดังนั้น การจัดการ Missing Values จะช่วยให้ข้อมูลมีคุณภาพสูงขึ้นและลดผลกระทบจากค่าที่ขาดหายไปได้

เป้าหมายหลักของการจัดการ Missing Values ได้แก่

1. เพิ่มคุณภาพของข้อมูล: การลบหรือเติมค่าแทนในตำแหน่งที่ข้อมูลขาดหายไปทำให้ข้อมูลสมบูรณ์และพร้อมต่อการใช้งาน โดยช่วยลดข้อผิดพลาดที่อาจเกิดจากค่าที่ไม่ครบถ้วน
2. ลด Bias ในการวิเคราะห์ข้อมูล: การมี Missing Values อาจสร้าง Bias ในการวิเคราะห์ได้ การจัดการค่าที่ขาดหายไปช่วยให้การวิเคราะห์มีความถูกต้องและแม่นยำมากขึ้น
3. เพิ่มประสิทธิภาพของโมเดล Machine Learning: ข้อมูลที่มี Missing Values อาจทำให้โมเดล Machine Learning เรียนรู้ได้ไม่ดีหรือทำงานผิดพลาด การจัดการ Missing Values จะช่วยให้โมเดลมีข้อมูลที่สมบูรณ์ในการเรียนรู้ และทำให้โมเดลมีประสิทธิภาพสูงขึ้น
4. รองรับการวิเคราะห์ได้เต็มที่: ช่วยให้เราสามารถนำข้อมูลไปใช้ในการวิเคราะห์และประมวลผลได้เต็มที่ โดยไม่ต้องกังวลถึงการขาดหายไปของค่า ซึ่งอาจทำให้ผลการวิเคราะห์ไม่สมบูรณ์หรือมีช่องว่างในการตีความผล
5. ลดการสูญเสียข้อมูล: การใช้วิธีการเติมค่าหรือประเมินค่า เช่น Interpolation หรือการเติมด้วยค่าเฉลี่ย ทำให้เราสามารถเก็บข้อมูลเดิมไว้ได้มากที่สุด แทนที่จะต้องลบแถวหรือคอลัมน์ที่มี Missing Values ออก

Duplicates

Duplicates หมายถึงแถวข้อมูลที่ซ้ำกัน ซึ่งอาจเกิดจากการรวบรวมข้อมูลจากหลายแหล่งหรือการบันทึกข้อมูลผิดพลาด การลบข้อมูลซ้ำจะช่วยให้การวิเคราะห์ข้อมูลมีความถูกต้องมากขึ้นและลดการใช้พื้นที่จัดเก็บข้อมูลโดยไม่จำเป็น

โดยปกติเราจะใช้ Pandas ในการจัดการข้อมูลซ้ำ โดยใช้คำสั่ง .duplicated() เพื่อตรวจสอบและ .drop_duplicates() เพื่อลบข้อมูลซ้ำ

ตัวอย่างข้อมูลซ้ำเช่นแบบนี้

import pandas as pd

# สร้าง DataFrame ตัวอย่างที่มีข้อมูลซ้ำ
data = {
    'id': [1, 2, 2, 3, 4, 5, 5],
    'name': ['Alice', 'Bob', 'Bob', 'Charlie', 'David', 'Eve', 'Eve'],
    'age': [24, 25, 25, 22, 29, 31, 31]
}

df = pd.DataFrame(data)
print("Original Data:")
print(df)

ผลลัพธ์ของ Dataframe

Original Data:
   id     name  age
0   1    Alice   24
1   2      Bob   25
2   2      Bob   25
3   3  Charlie   22
4   4    David   29
5   5      Eve   31
6   5      Eve   31

คำสั่งสำหรับจัดการกับ Duplicates ใน Python มักจะใช้ท่าเหล่านี้กัน

1. ตรวจสอบข้อมูลซ้ำ

ใช้ .duplicated() เพื่อดูว่ามีข้อมูลซ้ำอยู่ใน DataFrame หรือไม่ คำสั่งนี้จะคืนค่าเป็น True สำหรับแถวที่เป็นข้อมูลซ้ำ (ซึ่งอาจจะเป็นแถวแรกหรือไม่ก็ได้)

# ตรวจสอบแถวที่ซ้ำกัน
print("\nตรวจสอบแถวที่ซ้ำกัน:")
print(df.duplicated())

ผลลัพธ์

ตรวจสอบแถวที่ซ้ำกัน:
0    False
1    False
2     True
3    False
4    False
5    False
6     True
dtype: bool

2. ตรวจสอบข้อมูลซ้ำแบบกำหนด column เฉพาะ

หากต้องการตรวจสอบข้อมูลซ้ำเฉพาะบาง column เช่น เฉพาะ id หรือ name ก็สามารถระบุใน code ได้

# ตรวจสอบข้อมูลซ้ำในคอลัมน์ 'id'
print("\nตรวจสอบข้อมูลซ้ำในคอลัมน์ 'id':")
print(df.duplicated(subset=['id']))

# ตรวจสอบข้อมูลซ้ำในคอลัมน์ 'name'
print("\nตรวจสอบข้อมูลซ้ำในคอลัมน์ 'name':")
print(df.duplicated(subset=['name']))

ผลลัพธ์

ตรวจสอบข้อมูลซ้ำในคอลัมน์ 'id':
0    False
1    False
2     True
3    False
4    False
5    False
6     True
dtype: bool

ตรวจสอบข้อมูลซ้ำในคอลัมน์ 'name':
0    False
1    False
2     True
3    False
4    False
5    False
6     True
dtype: bool

3. ลบข้อมูลซ้ำ (Removing Duplicates)

ใช้ .drop_duplicates() เพื่อลบข้อมูลซ้ำออกจาก DataFrame โดยมี keep parameter ให้เลือก ตั้งแต่

• keep='first' เก็บแถวแรกไว้ (ค่าเริ่มต้น)
• keep='last':เก็บแถวสุดท้ายไว้
• keep=False ลบข้อมูลซ้ำทั้งหมด

# ลบข้อมูลซ้ำ โดยเก็บแถวแรกไว้
df_no_duplicates = df.drop_duplicates()
print("\nหลังจากลบข้อมูลซ้ำ (เก็บแถวแรกไว้):")
print(df_no_duplicates)

# ลบข้อมูลซ้ำ โดยเก็บแถวสุดท้ายไว้
df_no_duplicates_last = df.drop_duplicates(keep='last')
print("\nหลังจากลบข้อมูลซ้ำ (เก็บแถวสุดท้ายไว้):")
print(df_no_duplicates_last)

# ลบข้อมูลซ้ำทั้งหมด
df_no_duplicates_all = df.drop_duplicates(keep=False)
print("\nหลังจากลบข้อมูลซ้ำทั้งหมด:")
print(df_no_duplicates_all)

ผลลัพธ์

หลังจากลบข้อมูลซ้ำ (เก็บแถวแรกไว้):
   id     name  age
0   1    Alice   24
1   2      Bob   25
3   3  Charlie   22
4   4    David   29
5   5      Eve   31

หลังจากลบข้อมูลซ้ำ (เก็บแถวสุดท้ายไว้):
   id     name  age
0   1    Alice   24
2   2      Bob   25
3   3  Charlie   22
4   4    David   29
6   5      Eve   31

หลังจากลบข้อมูลซ้ำทั้งหมด:
   id     name  age
0   1    Alice   24
3   3  Charlie   22
4   4    David   29

4. ลบข้อมูลซ้ำเฉพาะบางคอลัมน์

# ลบข้อมูลซ้ำโดยดูเฉพาะคอลัมน์ 'id'
df_no_duplicates_id = df.drop_duplicates(subset=['id'])
print("\nหลังจากลบข้อมูลซ้ำโดยดูเฉพาะคอลัมน์ 'id':")
print(df_no_duplicates_id)

# ลบข้อมูลซ้ำโดยดูเฉพาะคอลัมน์ 'name'
df_no_duplicates_name = df.drop_duplicates(subset=['name'])
print("\nหลังจากลบข้อมูลซ้ำโดยดูเฉพาะคอลัมน์ 'name':")
print(df_no_duplicates_name)

ผลลัพธ์

หลังจากลบข้อมูลซ้ำโดยดูเฉพาะคอลัมน์ 'id':
   id     name  age
0   1    Alice   24
1   2      Bob   25
3   3  Charlie   22
4   4    David   29
5   5      Eve   31

หลังจากลบข้อมูลซ้ำโดยดูเฉพาะคอลัมน์ 'name':
   id     name  age
0   1    Alice   24
1   2      Bob   25
3   3  Charlie   22
4   4    David   29
5   5      Eve   31

เป้าหมายของการจัดการ Duplicates คือการทำให้ข้อมูลสะอาดและมีคุณภาพมากขึ้น การมีข้อมูลซ้ำกันอาจทำให้ผลการวิเคราะห์หรือการคาดการณ์ “เกิดความคลาดเคลื่อนได้” เนื่องจากการนับหรือคำนวณข้อมูลซ้ำอาจทำให้ผลลัพธ์ผิดพลาด การลบหรือจัดการข้อมูลซ้ำจึงเป็นขั้นตอนที่สำคัญในการทำ Data Cleaning เพื่อเพิ่มความแม่นยำและประสิทธิภาพในการวิเคราะห์ข้อมูล

Incorrect Data Format

Incorrect Data Format หมายถึงข้อมูลที่อยู่ในรูปแบบที่ไม่ถูกต้องหรือไม่สอดคล้องกับรูปแบบที่ต้องการ เช่น ข้อมูลวันที่ที่ไม่ได้อยู่ในรูปแบบวันที่จริง ข้อมูลตัวเลขที่ถูกบันทึกเป็นข้อความ หรือค่าที่ไม่ตรงกับประเภทข้อมูลที่ต้องการ การจัดการข้อมูลที่อยู่ในรูปแบบไม่ถูกต้องช่วยให้การวิเคราะห์ข้อมูลและการประมวลผลทำได้อย่างถูกต้องและแม่นยำมากขึ้น

การจัดการ Incorrect Data Format ด้วย Python สามารถใช้ Pandas ในการจัดการรูปแบบข้อมูลที่ผิดพลาด โดยสามารถแปลงข้อมูลให้เป็นรูปแบบที่ต้องการ เช่น การแปลงข้อมูลประเภทวันที่ (Date), ข้อความ (String), ตัวเลข (Integer/Float)

สมมุติว่า เรามี dataframe หน้าตาแบบนี้

import pandas as pd

# สร้าง DataFrame ตัวอย่างที่มีข้อมูลในรูปแบบที่ไม่ถูกต้อง
data = {
    'date': ['2023-01-01', '01-02-2023', 'March 5, 2023', '2023/04/01', 'not a date'],
    'price': ['100', '200.5', '300$', '400', '500THB'],
    'quantity': ['10', '20', 'thirty', '40', '50']
}

df = pd.DataFrame(data)
print("Original Data:")
print(df)

หน้าตา Dataframe (จะเห็นว่า format เละเทะไปหมด)

Original Data:
            date   price quantity
0     2023-01-01     100       10
1     01-02-2023   200.5       20
2  March 5, 2023    300$   thirty
3     2023/04/01     400       40
4     not a date  500THB       50

เคสที่ใช้แปลงข้อมูล format ในแต่ละประเภทให้ถูกต้องก็จะมีดังนี้

1. การแปลงข้อมูลวันที่ (Date)

กรณีที่มีข้อมูลวันที่ในหลายรูปแบบหรือมีค่าที่ไม่ใช่วันที่จริง ๆ สามารถใช้ pd.to_datetime() เพื่อแปลงข้อมูลคอลัมน์ให้เป็นรูปแบบวันที่ โดย errors='coerce' จะเปลี่ยนค่าที่ไม่ใช่วันที่ให้เป็น NaT (Not a Time)

# แปลงคอลัมน์ 'date' ให้เป็นรูปแบบวันที่
df['date'] = pd.to_datetime(df['date'], errors='coerce')
print("\nหลังจากแปลงข้อมูลวันที่ (Date):")
print(df)

Result

หลังจากแปลงข้อมูลวันที่ (Date):
        date   price quantity
0 2023-01-01     100       10
1        NaT   200.5       20
2        NaT    300$   thirty
3        NaT     400       40
4        NaT  500THB       50

แต่สังเกตว่า มันจะแปลงถูกออกมาแค่ format เดียวซึ่งเป็น format แรกสุดของข้อมูล โดย pd.to_datetime ตัวมันเองนั้น support หลาย format ก็จริง แต่มันจะทำการเลือก format “ตามตัวแรกสุด” เป็น base ออกมา ดังนั้น เมื่อ date แต่ละตัวมี format ต่างกันทำให้ pd.to_datetime ไม่สามารถแปลงตัวอื่นๆ ที่ไม่เหมือนกับตัวแรกได้

โดย pd.to_datetime เราสามารถกำหนดให้แต่ละ format มาเป็น format ที่ถูกต้องได้โดยการกำกับผ่าน format ใน pd.to_datetime ได้แบบนี้

# แปลงคอลัมน์ 'date' ให้เป็นรูปแบบวันที่โดยใช้หลายรูปแบบในการแปลง
def parse_date(date):
    for fmt in ('%Y-%m-%d', '%d-%m-%Y', '%B %d, %Y', '%Y/%m/%d'):
        try:
            return pd.to_datetime(date, format=fmt)
        except (ValueError, TypeError):
            continue
    return pd.NaT  # Return NaT if no format matches

print("\nหลังจากแปลงข้อมูลวันที่ (Date) ใหม่:")
# Apply the parse_date function
df['date'] = df['date'].apply(parse_date)
print(df)

ก็จะสามารถแก้ปัญหาดังกล่าว และได้ผลลัพธ์ออกมาได้ ผลลัพธ์

หลังจากแปลงข้อมูลวันที่ (Date) ใหม่:
        date   price quantity
0 2023-01-01     100       10
1 2023-02-01   200.5       20
2 2023-03-05    300$   thirty
3 2023-04-01     400       40
4        NaT  500THB       50

2. การแปลงข้อมูลตัวเลข (Numeric)

บางครั้งข้อมูลที่ควรเป็นตัวเลขจะอยู่ในรูปแบบข้อความหรือมีตัวอักษรที่ไม่จำเป็น เช่น สัญลักษณ์ $ หรือ THB ใช้ pd.to_numeric() เพื่อแปลงข้อมูลให้เป็นตัวเลข โดยใช้ errors='coerce' เพื่อให้ค่าที่ไม่ใช่ตัวเลขกลายเป็น NaN

# ลบสัญลักษณ์ที่ไม่จำเป็นและแปลงข้อมูลเป็นตัวเลข
df['price'] = pd.to_numeric(df['price'].str.replace(r'[^\d.]', '', regex=True), errors='coerce')
print("\nหลังจากแปลงข้อมูลราคา (Price) ให้เป็นตัวเลข:")
print(df)

ผลลัพธ์

หลังจากแปลงข้อมูลราคา (Price) ให้เป็นตัวเลข:
            date  price quantity
0     2023-01-01  100.0       10
1     01-02-2023  200.5       20
2  March 5, 2023  300.0   thirty
3     2023/04/01  400.0       40
4     not a date  500.0       50

3. การแปลงข้อมูลข้อความเป็นตัวเลข (String to Numeric)

กรณีที่ข้อมูลตัวเลขอาจถูกบันทึกเป็นข้อความ เช่น quantity บางรายการเป็นตัวเลข ขณะที่บางรายการเป็นคำ ตัวอย่างนี้ใช้ .replace() และ pd.to_numeric() เพื่อลบค่าที่เป็นข้อความออก

# แปลงข้อมูลคอลัมน์ 'quantity' เป็นตัวเลข โดยเปลี่ยนค่าที่ไม่ใช่ตัวเลขให้เป็น NaN
df['quantity'] = pd.to_numeric(df['quantity'], errors='coerce')
print("\nหลังจากแปลงข้อมูลจำนวน (Quantity) ให้เป็นตัวเลข:")
print(df)

ผลลัพธ์

หลังจากแปลงข้อมูลจำนวน (Quantity) ให้เป็นตัวเลข:
            date   price  quantity
0     2023-01-01     100      10.0
1     01-02-2023   200.5      20.0
2  March 5, 2023    300$       NaN
3     2023/04/01     400      40.0
4     not a date  500THB      50.0

4. การแปลงข้อมูลให้เป็นข้อความ (String)

บางครั้งข้อมูลที่เป็นข้อความอาจอยู่ในรูปแบบอื่น เช่น ข้อมูลที่เป็นตัวเลขหรือวันที่ที่ต้องการแปลงเป็นข้อความโดยใช้ .astype(str)

# แปลงข้อมูลคอลัมน์ 'price' เป็นข้อความ (String) ในกรณีที่ต้องการเก็บในรูปแบบนี้
df['price'] = df['price'].astype(str)
print("\nหลังจากแปลงข้อมูลราคา (Price) ให้เป็นข้อความ:")
print(df)

ผลลัพธ์

หลังจากแปลงข้อมูลราคา (Price) ให้เป็นข้อความ:
            date   price quantity
0     2023-01-01     100       10
1     01-02-2023   200.5       20
2  March 5, 2023    300$   thirty
3     2023/04/01     400       40
4     not a date  500THB       50

Outliers

Outliers คือ ค่าหรือข้อมูลบางค่าที่มีความแตกต่างอย่างมากจากข้อมูลอื่น ๆ ในชุดข้อมูล ซึ่งมักจะเป็นค่าที่สูงหรือต่ำเกินไปเมื่อเทียบกับค่าปกติของข้อมูลชุดนั้น การมี Outliers อาจทำให้ผลลัพธ์ที่ได้จากการวิเคราะห์ข้อมูลผิดเพี้ยนหรือไม่แม่นยำได้

ตัวอย่างเช่น ข้อมูลอายุของนักเรียนในชั้นเรียนที่อายุตั้งแต่ 10 ถึง 12 ปี แต่มีนักเรียนคนหนึ่งอายุ 40 ปี นักเรียนคนนี้อาจถือเป็น Outlier เพราะค่าอายุของเขาแตกต่างอย่างมากจากนักเรียนคนอื่น ๆ

ตัวอย่างการใช้ Python กับ DataFrame เพื่อหาค่า Outliers ด้วยการใช้ไตรมาสที่ 1 (Q1) และไตรมาสที่ 3 (Q3) เพื่อกำหนดขอบเขตของ Outliers

import pandas as pd
import numpy as np

# สร้าง DataFrame ตัวอย่าง
data = {
    'Student_ID': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
    'Age': [10, 11, 12, 10, 11, 10, 11, 12, 40, 11]
}
df = pd.DataFrame(data)

# คำนวณ Q1 และ Q3
Q1 = df['Age'].quantile(0.25)
Q3 = df['Age'].quantile(0.75)
IQR = Q3 - Q1

# กำหนดขอบเขตของ Outliers
lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR

# หา Outliers
outliers = df[(df['Age'] < lower_bound) | (df['Age'] > upper_bound)]
print("Outliers:")
print(outliers)

ใน code นี้

• Q1 คือไตรมาสที่ 1 (25% ของข้อมูล)
• Q3 คือไตรมาสที่ 3 (75% ของข้อมูล)
• IQR คือช่วงไตรมาส (Q3 - Q1) ใช้ในการกำหนดขอบเขตของ Outliers
• lower_bound และ upper_bound ใช้กำหนดช่วงค่าที่ไม่ถือว่าเป็น Outliers

ผลลัพธ์ที่ได้จะแสดงแถวที่มี Age เป็น Outlier

Outliers:
   Student_ID  Age
8           9   40

ในตัวอย่างนี้ ค่า Age ของนักเรียนคนหนึ่งมีค่าเป็น 40 ซึ่งถือว่าเป็น Outlier เนื่องจากค่าดังกล่าวแตกต่างอย่างมากจากค่าปกติของอายุของนักเรียนคนอื่น ๆ ในชั้นเรียนที่มีอายุเฉลี่ยอยู่ในช่วง 10 ถึง 12 ปี เมื่อมีค่าอายุที่แตกต่างสูงหรือต่ำกว่าค่าปกติมาก ๆ เช่นนี้ จึงทำให้ค่า 40 เป็นค่าที่โดดออกมาจากชุดข้อมูล

การจัดการกับข้อมูลที่เป็น Outliers สามารถทำได้หลายวิธี ขึ้นอยู่กับประเภทของข้อมูลและวัตถุประสงค์ของการวิเคราะห์ โดยมีวิธีการที่นิยมใช้ดังนี้

1. ลบข้อมูลที่เป็น Outliers ออก

ถ้าข้อมูลที่เป็น Outliers ไม่ได้มีความสำคัญหรือไม่ได้ส่งผลต่อการวิเคราะห์ อาจพิจารณาลบทิ้งได้ โดยเฉพาะเมื่อจำนวน Outliers มีน้อยและไม่กระทบกับข้อมูลส่วนใหญ่

# ตัวอย่างการลบ Outliers ออกจาก DataFrame
df_no_outliers = df[(df['Age'] >= lower_bound) & (df['Age'] <= upper_bound)]

2. การแทนที่ Outliers ด้วยค่าที่เหมาะสม (Imputation)

สามารถแทนที่ค่า Outliers ด้วยค่าเฉลี่ย มัธยฐาน หรือค่าที่เหมาะสม เช่น ค่า Q1, Q3 หรือค่ากลางของข้อมูลเพื่อลดผลกระทบ

# ตัวอย่างการแทนที่ Outliers ด้วยมัธยฐาน
median_age = df['Age'].median()
df['Age'] = np.where((df['Age'] < lower_bound) | (df['Age'] > upper_bound), median_age, df['Age'])

3. การปรับขนาดข้อมูล (Capping/Flooring)

การจำกัดค่าสูงสุดและต่ำสุดให้เท่ากับขอบเขตของ Outliers (lower bound หรือ upper bound) เพื่อลดผลกระทบจากค่าสุดโต่ง

# ตัวอย่างการปรับขนาดข้อมูล
df['Age'] = np.where(df['Age'] > upper_bound, upper_bound, 
                     np.where(df['Age'] < lower_bound, lower_bound, df['Age']))
                     
print("DataFrame after adjusting outliers:")
print(df)

ผลลัพธ์

DataFrame after adjusting outliers:
   Student_ID   Age
0           1  10.0
1           2  11.0
2           3  12.0
3           4  10.0
4           5  11.0
5           6  10.0
6           7  11.0
7           8  12.0
8           9  14.0
9          10  11.0

4. การใช้วิธีการแปลงข้อมูล (Transformation)

ใช้การแปลงข้อมูล เช่น Log Transformation, Square Root Transformation หรือ Box-Cox Transformation เพื่อลดผลกระทบของ Outliers และทำให้ข้อมูลมีการกระจายตัวที่สมดุลมากขึ้น

# ตัวอย่างการแปลงข้อมูลด้วย Log Transformation
df['Age'] = np.log1p(df['Age'])  # ใช้ log1p เพื่อป้องกัน log(0)

หรืออาจจะใช้เทคนิคอื่นๆ เช่น ใช้โมเดลที่ทนต่อ Outliers ได้ (Robust Model) อย่าง Decision Tree หรือ Random Forest ที่ไม่ได้รับผลกระทบมากจาก Outliers หรือ ใช้เทคนิคการจัดกลุ่ม เช่น K-means Clustering หรือ DBSCAN เพื่อค้นหาและแยก Outliers ออกจากกลุ่มข้อมูลหลัก จากนั้นสามารถจัดการ Outliers เหล่านั้นได้ตามความเหมาะสม (เดี๋ยวเทคนิคเหล่านี้ เราจะกลับมาเจาะลึกกันอีกทีในหัวข้อตระกูล Machine Learning กัน)

เป้าหมายหลักของการจัดการข้อมูลที่เป็น Outliers คือการลดผลกระทบที่อาจทำให้ผลการวิเคราะห์ข้อมูลผิดเพี้ยนหรือไม่แม่นยำ เนื่องจาก Outliers มักเป็นค่าที่มีความแตกต่างอย่างมากจากค่าปกติของข้อมูล หากไม่มีการจัดการ อาจทำให้ค่าทางสถิติเช่น ค่าเฉลี่ย หรือส่วนเบี่ยงเบนมาตรฐานไม่สะท้อนข้อมูลที่แท้จริงออกมาได้ (เดี๋ยวเราจะเจาะลึกกันในหัวข้อสถิติอีกที)

นอกจากนี้ การจัดการ Outliers ยังช่วยให้การตัดสินใจจากข้อมูลมีความน่าเชื่อถือมากขึ้น โดยการกำจัดหรือลดผลกระทบจาก Outliers ทำให้การวิเคราะห์และการตัดสินใจมีพื้นฐานจากข้อมูลที่แท้จริงและมีความเสถียร สิ่งนี้สำคัญสำหรับงานที่ต้องใช้ข้อมูลในการตัดสินใจเชิงธุรกิจ เช่น การวางแผนกลยุทธ์ การพยากรณ์ทางการเงิน หรือการวิเคราะห์เชิงวิทยาศาสตร์ ซึ่งต้องการข้อมูลที่สะท้อนความเป็นจริงมากที่สุด