การเตรียมข้อมูล (Data Preparation) สำหรับ Deep Learning

การเตรียมข้อมูล (Data Preparation) เป็นขั้นตอนสำคัญในการสร้างและประเมินโมเดล Deep Learning โดยมีเป้าหมายเพื่อเตรียมข้อมูลให้เหมาะสมกับการฝึกฝน (training) และทดสอบ (testing) โมเดล ซึ่งสามารถทำได้โดยจัดการข้อมูลให้อยู่ในรูปแบบที่ถูกต้อง และตรวจสอบความถูกต้องของข้อมูลเพื่อป้องกันการเรียนรู้ที่ผิดพลาด (overfitting) หรือการเรียนรู้ที่ไม่เหมาะสม (underfitting) เพื่อแก้ไขปัญหาต่างๆ ซึ่งมีวัตถุประสงค์เพื่อเตรียมข้อมูลให้เหมาะสมและสามารถนำไปใช้ในการสร้างและทดสอบโมเดลได้อย่างมีประสิทธิภาพ การเตรียมข้อมูลประกอบด้วยขั้นตอนต่างๆ ดังนี้

1. การเก็บรวบรวมข้อมูล (Data Collection)  การเก็บรวบรวมข้อมูลจะต้องใช้วิธีการเหมาะสมเพื่อเข้าถึงข้อมูลในปริมาณที่มากพอที่จะสามารถสร้างโมเดลได้ เช่น การเก็บรูปภาพด้วยกล้องถ่ายภาพ การดึงข้อมูลจากฐานข้อมูล หรือการดึงข้อมูลจากเว็บไซต์ต่างๆ เป็นต้น การจัดรูปแบบและเตรียมข้อมูลให้เหมาะสมสำหรับการนำเข้าโมเดล Deep Learning เช่น การกำหนดรูปแบบของข้อมูลเข้ากับโมเดล เช่น การแปลงข้อมูลอักษรเป็นตัวเลขและการเปลี่ยนรูปแบบของข้อมูลเป็นรูปแบบที่สามารถใช้กับโมเดลได้

2. การตรวจสอบและทำความสะอาดข้อมูล (Data Inspection and Cleaning)  การตรวจสอบและทำความสะอาดข้อมูลเป็นขั้นตอนสำคัญเพื่อลดปัญหาการเกิดข้อผิดพลาดในการเรียนรู้ของโมเดล โดยประกอบด้วยการตรวจสอบความสมบูรณ์และความถูกต้องของข้อมูล การลบข้อมูลที่ไม่เหมาะสม การแก้ไขข้อมูลที่ไม่ถูกต้อง เช่น ข้อมูลที่หายไป ข้อมูลที่ไม่สมบูรณ์ หรือข้อมูลที่ซ้ำกัน เป็นต้น การตรวจสอบและจัดการกับข้อมูลที่เสียหาย หรือข้อมูลที่ไม่ถูกต้อง เช่น ข้อมูลที่ขาดหายไป (missing data) หรือข้อมูลที่ไม่ถูกต้อง (incorrect data) เพื่อให้ข้อมูลมีคุณภาพที่ดีกว่า และสามารถนำมาใช้กับโมเดล Deep Learning ได้

3. การแบ่งข้อมูล (Data Splitting) ในขั้นตอนนี้จะเป็นการแบ่งข้อมูลออกเป็นชุดข้อมูลสำหรับฝึกฝน (training set) และชุดข้อมูลสำหรับทดสอบ (testing set) เพื่อใช้ในการฝึกฝนและประเมินโมเดล โดยปกติแล้วจะแบ่งเป็นสัดส่วนที่เหมาะสม เช่น 80% สำหรับฝึกฝนและ 20% สำหรับทดสอบ การแบ่งข้อมูลเป็นชุด Train, Validation และ Test เป็นการแบ่งข้อมูลเพื่อให้สามารถวัดประสิทธิภาพของโมเดลได้ โดยมักจะแบ่งข้อมูลเป็นอย่างน้อย 2 ชุด คือ Train และ Test แต่บางครั้งอาจมีการแบ่งเป็น Train, Validation และ Test เพื่อใช้สำหรับการปรับแต่ง Hyperparameters และทำแบบทดสอบ (Testing) การแบ่งชุดข้อมูลเป็นชุดฝึกฝนและชุดทดสอบเพื่อวัดประสิทธิภาพของโมเดล โดยทั่วไปจะแบ่งชุดข้อมูลออกเป็นสัดส่วนสำหรับฝึกฝนและทดสอบ ซึ่งจะช่วยให้มั่นใจได้ว่าโมเดลของเราสามารถทำงานกับข้อมูลที่ไม่เคยเห็นมาก่อนได้

4. การแปลงข้อมูล (Data Transformation) การแปลงข้อมูลเป็นขั้นตอนที่สำคัญเพื่อเตรียมข้อมูลให้เหมาะสมกับโมเดลที่ใช้ โดยส่วนใหญ่จะมีการแปลงข้อมูลเป็นรูปภาพ (Image) หรือตัวเลข (Numerical) เช่น การปรับขนาดภาพ (Image Resizing) การทำ Augmentation เพื่อเพิ่มจำนวนข้อมูล หรือการทำ Normalization เพื่อปรับค่าความสัมพันธ์ระหว่างข้อมูล เป็นต้น ซึ่งการ Scaling ข้อมูล (Normalization) เป็นกระบวนการที่สำคัญในการเตรียมข้อมูลสำหรับ Deep Learning โดยทั่วไปแล้วจะนำมาใช้เมื่อข้อมูลต้นฉบับมีความแตกต่างกันในช่วงของช่องค่าต่างๆ ซึ่งอาจจะทำให้โมเดล Deep Learning ไม่สามารถเรียนรู้และทำนายผลได้ดีตามความเป็นจริง หลักการของ Scaling หรือ Normalization คือการปรับแต่างข้อมูลให้มี mean และ standard deviation เท่ากับ 0 และ 1 ตามลำดับ เพื่อให้ค่าของข้อมูลมีความเข้ากันได้และสามารถนำมาประมวลผลได้ดีขึ้น การปรับข้อมูลให้เป็นช่วงหรือมาตรฐานที่เหมาะสม เช่น การแปลงข้อมูลให้อยู่ในช่วง [0,1] หรือ [-1,1] เพื่อให้โมเดลสามารถเรียนรู้และดำเนินการได้อย่างมีประสิทธิภาพ

การเก็บรวบรวมข้อมูล (Data Collection)

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

1. กำหนดแหล่งข้อมูล: กำหนดว่าจะเก็บข้อมูลมาจากแหล่งใด เช่นเว็บไซต์, โซเชียลมีเดีย, หรือแหล่งข้อมูลอื่นๆ

2. ใช้ Python Libraries: ใช้ไลบรารี Python เช่น requests, BeautifulSoup, pandas เพื่อสร้างโปรแกรมสำหรับดึงข้อมูลอัตโนมัติจากแหล่งข้อมูลที่กำหนด

3. ตั้งค่าการเชื่อมต่อ: ตั้งค่าการเชื่อมต่อเพื่อเข้าถึงแหล่งข้อมูล เช่นการตั้งค่า API Key, การเชื่อมต่อฐานข้อมูล, หรือการตั้งค่าการใช้งานเว็บไซต์

4. ดึงข้อมูล: ใช้ Python Libraries เพื่อดึงข้อมูลจากแหล่งข้อมูล โดยส่วนใหญ่จะใช้ requests ในการร้องขอข้อมูล และ BeautifulSoup เพื่อดึงข้อมูลจาก HTML

5. จัดเก็บข้อมูล: จัดเก็บข้อมูลที่ดึงมาเป็นไฟล์ CSV, JSON, หรือไฟล์อื่นๆ เพื่อนำไปใช้ในการฝึกสอนโมเดล Deep Learning

การเก็บรวบรวมข้อมูลสามารถดึงจากเว็บไซต์ต่างๆ ได้ ด้วยการใช้ Python ไลบรารี่ BeautifulSoup ตัวอย่างเช่น

import requests
from bs4 import BeautifulSoup

# ระบุ URL ของหน้าเว็บไซต์ที่ต้องการดึงข้อมูล
url = "https://www.example.com"

# ใช้ requests library เพื่อเรียกดูหน้าเว็บไซต์
response = requests.get(url)

# ใช้ BeautifulSoup library เพื่อแปลงข้อมูลในหน้าเว็บไซต์เป็นโครงสร้างต้นแบบ (HTML DOM)
soup = BeautifulSoup(response.content, "html.parser")

# ค้นหาแท็ก <p> ใน HTML DOM และพิมพ์เนื้อหาของแต่ละแท็กออกมา
for paragraph in soup.find_all('p'):
    print(paragraph.text)

จากตัวอย่าง จะเรียกดูข้อมูลจากเว็บไซต์ https://www.example.com และแสดงผลลัพธ์ที่มีแท็ก <p> ออกมาทั้งหมดด้วยคำสั่ง print(paragraph.text)

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

import requests
from bs4 import BeautifulSoup

# กำหนด URL และข้อมูลสำหรับเปิดเชื่อมต่อ
url = "https://www.amazon.com/s?i=stripbooks&bbn=283155&rh=n%3A283155%2Cp_36%3A0-20&dc&qid=1634801376&rnid=386491011&ref=sr_nr_p_36_0"
headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36'}

# สร้างการเรียกขอข้อมูล
response = requests.get(url, headers=headers)

# ประมวลผล HTML ด้วย BeautifulSoup
soup = BeautifulSoup(response.content, 'html.parser')

# ค้นหากลุ่มสินค้าในหน้าเว็บไซต์
results = soup.find_all('div', {'data-component-type': 's-search-result'})

# ลูปผ่านกลุ่มสินค้าและแยกข้อมูล
for result in results:
    try:
        # ค้นหาชื่อหนังสือ
        title = result.find('h2', {'class': 'a-size-mini a-spacing-none a-color-base s-line-clamp-2'}).text.strip()
        # ค้นหาราคา
        price = result.find('span', {'class': 'a-offscreen'}).text.strip()
        # ค้นหาคะแนนเฉลี่ยของผู้ใช้
        rating = result.find('span', {'class': 'a-icon-alt'}).text.strip().split()[0]
        print(title, price, rating)
    except:
        # ไม่พบข้อมูลในกลุ่มสินค้านี้ ข้ามไปยังกลุ่มสินค้าถัดไป
        continue

เห็นว่าการใช้งาน BeautifulSoup เป็นเครื่องมือที่มีประโยชน์ในการเก็บรวบรวมข้อมูลจากเว็บไซต์อย่างอัตโนมัติ

ในตัวอย่างนี้ เราใช้ requests library เพื่อเปิดเชื่อมต่อไปยัง URL และ BeautifulSoup library เพื่อทำการประมวลผล HTML ที่ได้รับจากเว็บไซต์ โดยใช้ method find_all() ในการค้นหากลุ่มของสินค้า และ method find() เพื่อค้นหาข้อมูลเฉพาะของแต่ละสินค้าภายในกลุ่มนั้นๆ

การใช้ try-except block ในลูป for เป็นเรื่องสำคัญเพื่อป้องกันการหยุดทำงานของโปรแกรมเมื่อพบข้อผิดพลาดในการค้นหาข้อมูลในกลุ่มสินค้านั้นๆ และการใช้ continue statement ใน except block เพื่อข้ามไปยังกลุ่มสินค้าถัดไปในกรณีที่ไม่พบข้อมูลสำหรับกลุ่มสินค้านั้นๆ

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

การตรวจสอบและทำความสะอาดข้อมูล (Data Inspection and Cleaning)

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

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

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

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

ตัวอย่าง การตรวจสอบและทำความสะอาดข้อมูลด้วย Python

import pandas as pd

# โหลดข้อมูลจากไฟล์ csv
df = pd.read_csv('data.csv')

# แสดงจำนวนแถวและคอลัมน์ของข้อมูล
print('Data shape:', df.shape)

# ตรวจสอบและแสดงข้อมูลหัวตาราง
print('Head of data:')
print(df.head())

# ตรวจสอบค่า null ในแต่ละคอลัมน์
print('Null values:')
print(df.isnull().sum())

# ลบแถวที่มีค่า null
df.dropna(inplace=True)

# ตรวจสอบและแสดงข้อมูลหัวตารางหลังจากทำการลบแถวที่มีค่า null
print('Head of data after dropping null values:')
print(df.head())

# แปลงคอลัมน์ category เป็น one-hot encoding
df = pd.get_dummies(df, columns=['category'])

# แสดงจำนวนแถวและคอลัมน์ของข้อมูลหลังจากทำการ one-hot encoding
print('Data shape after one-hot encoding:', df.shape)

# แสดงตัวอย่างข้อมูลหลังจากทำการ one-hot encoding
print('Head of data after one-hot encoding:')
print(df.head())

จากตัวอย่างนี้ ข้อมูลถูกโหลดจากไฟล์ CSV และแสดงข้อมูลหัวตารางเพื่อตรวจสอบว่าข้อมูลถูกโหลดอย่างถูกต้องหรือไม่ และตรวจสอบว่ามีค่า null ในแต่ละคอลัมน์หรือไม่ ถ้าพบค่า null ข้อมูลจะถูกลบ และคอลัมน์ category จะถูกแปลงเป็น one-hot encoding เพื่อเตรียมข้อมูลสำหรับการฝึกอบรม Deep Learning และข้อมูลหัวตารางจะถูกแสดงอีกครั้งหลังจากการดำเนินการ one-hot encoding

ตัวอย่าง Python สำหรับการตรวจสอบและทำความสะอาดข้อมูล

import pandas as pd

# โหลดไฟล์ข้อมูล
df = pd.read_csv('data.csv')

# แสดงข้อมูลตั้งต้น
print(df.head())

# ตรวจสอบชนิดข้อมูลของแต่ละคอลัมน์
print(df.dtypes)

# ตรวจสอบค่าหายไป
print(df.isnull().sum())

# ลบแถวที่มีค่าหายไป
df = df.dropna()

# ตรวจสอบขนาดของชุดข้อมูลหลังจากลบแถวที่มีค่าหายไป
print(df.shape)

# กำหนดชื่อคอลัมน์
df.columns = ['age', 'gender', 'income', 'credit_score', 'purchased']

# แปลงชนิดข้อมูลของคอลัมน์ 'age' จาก float เป็น int
df['age'] = df['age'].astype(int)

# แปลงข้อมูลในคอลัมน์ 'gender' จาก male/female เป็น 0/1
df['gender'] = df['gender'].apply(lambda x: 1 if x == 'female' else 0)

# แปลงข้อมูลในคอลัมน์ 'purchased' จาก yes/no เป็น 1/0
df['purchased'] = df['purchased'].apply(lambda x: 1 if x == 'yes' else 0)

# แสดงข้อมูลหลังจากทำความสะอาด
print(df.head())

จากตัวอย่างนี้ ใช้ Pandas เพื่อโหลดไฟล์ข้อมูล csv และทำการตรวจสอบและทำความสะอาดข้อมูล โดยใช้คำสั่ง dtypes เพื่อตรวจสอบชนิดของข้อมูลในแต่ละคอลัมน์ isnull() เพื่อตรวจสอบค่าหายไปและลบแถวที่มีค่าหายไปด้วย dropna() นอกจากนี้เรายังกำหนดชื่อคอลัมน์และแปลงข้อมูลในคอลัมน์ต่างๆให้เหมาะสมด้วยฟังก์ชัน apply() และ astype() ตามลำดับ ก่อนที่จะแสดงข้อมูลหลัง

การแบ่งข้อมูล (Data Splitting)

เป็นกระบวนการแบ่งข้อมูลออกเป็นชุดสอน (Training Set) และชุดทดสอบ (Testing Set) เพื่อใช้สำหรับการสร้างและประเมินโมเดล Deep Learning ให้มีประสิทธิภาพสูงสุด การแบ่งข้อมูลสามารถทำได้โดยใช้ฟังก์ชัน train_test_split() ของโมดูล sklearn ของภาษา Python สำหรับการแบ่งข้อมูลด้วย train_test_split() ดังนี้

from sklearn.model_selection import train_test_split

# แบ่งข้อมูลออกเป็นชุดสอนและชุดทดสอบ โดยใช้ test_size 0.2 หมายถึงแบ่งข้อมูลสำหรับทดสอบออกเป็น 20% ของข้อมูลทั้งหมด
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

โดยที่ X คือ feature ของข้อมูล และ y คือ target หรือ output ของข้อมูล ตัวแปร test_size กำหนดส่วนส่วนของข้อมูลที่จะใช้สำหรับทดสอบ และ random_state ใช้สำหรับกำหนดค่า seed ในการสุ่มข้อมูล เพื่อให้การแบ่งข้อมูลเหมือนกันทุกครั้งที่ทำการแบ่งข้อมูล

หลังจากแบ่งข้อมูลเสร็จเรียบร้อยแล้ว จะได้ X_train, y_train สำหรับสร้างโมเดล และ X_test, y_test สำหรับทดสอบโมเดลที่สร้างขึ้น โดยใช้ชุดข้อมูล X_train, y_train ในการสร้างโมเดล และใช้ชุดข้อมูล X_test, y_test ในการทดสอบประสิทธิภาพของโมเดลที่สร้างขึ้น

ตัวอย่าง การแบ่งข้อมูล (Data Splitting) สำหรับ Deep Learning โดยใช้ scikit-learn

import numpy as np
from sklearn.model_selection import train_test_split

# สร้างข้อมูลสุ่มขนาด 1000 x 10
X = np.random.rand(1000, 10)
y = np.random.randint(2, size=1000)

# แบ่งข้อมูลเป็นชุด train และ test ด้วยสัดส่วน 70:30
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

จากตัวอย่าง ได้ใช้ numpy เพื่อสร้างข้อมูลสุ่มขนาด 1000 x 10 พร้อมกับตัวเลขเป้าหมายที่สุ่มด้วย numpy.random.randint() และแบ่งข้อมูลเป็นชุด train และ test ด้วยฟังก์ชั่น train_test_split() ของ scikit-learn โดยกำหนดสัดส่วนของชุดทดสอบเป็น 30% และกำหนด random state เพื่อให้ผลการแบ่งข้อมูลเหมือนกันทุกครั้งที่รันโค้ด

เมื่อเราแบ่งข้อมูลเป็นชุดฝึกฝน (training set) และชุดทดสอบ (test set) เราจะต้องระวังไม่ให้ข้อมูลซ้ำซ้อนกันระหว่างชุดฝึกฝนและชุดทดสอบ เพราะจะทำให้ผลการทดสอบไม่ถูกต้องและไม่สามารถใช้งานได้จริง

ในบางกรณี เราอาจต้องการแบ่งข้อมูลออกเป็นชุดฝึกฝน (training set) ชุดทดสอบ (test set) และชุดการตรวจสอบ (validation set) ซึ่งชุดการตรวจสอบนี้จะถูกใช้ในการปรับแต่งพารามิเตอร์ของโมเดล เช่น learning rate, dropout rate, หรือจำนวนเลเยอร์ที่ใช้ ซึ่งชุดการตรวจสอบนี้จะไม่ถูกใช้ในการปรับแต่งพารามิเตอร์ในการฝึกฝนแต่อย่างใด แต่จะถูกใช้เพื่อตรวจสอบว่าโมเดลของเรามีประสิทธิภาพอย่างไรกับชุดข้อมูลที่ไม่เคยเห็นมาก่อน

การแปลงข้อมูล (Data Transformation)

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

1. Scaling / Normalization: เป็นการปรับสเกลข้อมูลให้อยู่ในช่วงที่เหมาะสม เช่นการแปลงค่าตัวเลขจาก 0 ถึง 255 ให้เป็นช่วง 0 ถึง 1

2. Encoding: เป็นการแปลงข้อมูลไม่ตัวเลขให้อยู่ในรูปแบบของตัวเลข เช่นการแปลงข้อมูลประเภทเป็น one-hot encoding

3. Feature engineering: เป็นการสร้าง feature ใหม่จากข้อมูลที่มีอยู่ โดยใช้วิธีการต่างๆ เช่นการสร้าง feature จากข้อมูลวันเวลา การสร้าง feature จากข้อมูลตำแหน่งพิกัด

4. Dimensionality reduction: เป็นการลดจำนวน feature ในข้อมูล เพื่อลดความซับซ้อนของข้อมูลและลดเวลาในการสร้างโมเดล เช่นการใช้ PCA (Principal Component Analysis) ในการลดจำนวน feature

5. Augmentation: เป็นการสร้างข้อมูลใหม่จากข้อมูลที่มีอยู่ โดยใช้วิธีการต่างๆ เช่นการสร้างข้อมูลใหม่จากการหมุนหรือการเพิ่มเติมข้อมูล

การแปลงข้อมูล (Data Transformation) เป็นขั้นตอนที่สำคัญในการเตรียมข้อมูลสำหรับการนำมาใช้ในการสร้างแบบจำลอง Deep Learning โดยการแปลงข้อมูลนั้นมีได้หลายวิธี อาทิเช่น การเปลี่ยนแปลงคุณลักษณะ (Feature Engineering) การแปลงขนาดภาพ (Image Resizing) การแปลงข้อมูลเสียง (Audio Transformation) และอื่นๆ

การแปลงข้อมูลที่ถูกต้องจะช่วยให้โมเดล Deep Learning มีประสิทธิภาพสูง และทำให้โมเดลสามารถเรียนรู้และทำนายผลได้ถูกต้องมากขึ้น ตัวอย่างเช่น การแปลงขนาดภาพ (Image Resizing) ทำให้ภาพมีขนาดเหมือนกัน และลดจำนวนข้อมูลเพื่อให้โมเดลสามารถเรียนรู้ได้เร็วขึ้น การเปลี่ยนแปลงคุณลักษณะ (Feature Engineering) อาจทำการเลือกคุณลักษณะที่เกี่ยวข้องกับผลลัพธ์ที่ต้องการทำนาย เพื่อลดจำนวนคุณลักษณะที่ไม่เกี่ยวข้องออกไป และทำให้โมเดลเรียนรู้ได้เร็วขึ้นและมีประสิทธิภาพสูงขึ้น การแปลงข้อมูลเป็นส่วนสำคัญของกระบวนการเตรียมข้อมูล (Data Preparation) และช่วยให้โมเดล Deep Learning มีประสิทธิภาพสูงที่สุดในการทำนายผลลัพธ์ที่ต้องการ

ตัวอย่าง การแปลงข้อมูล (Data Transformation) สำหรับ Deep Learning ด้วยไลบรารี Scikit-learn

from sklearn.preprocessing import MinMaxScaler
import numpy as np

# สร้างข้อมูลตัวอย่าง
X = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# สร้างตัวแปร scaler และทำการเรียนรู้ช่วงของการแปลงข้อมูล
scaler = MinMaxScaler(feature_range=(0, 1))
scaler.fit(X)

# แปลงข้อมูล
transformed_X = scaler.transform(X)

# แสดงผล
print(transformed_X)

ผลลัพธ์คือ

[[0.   0.   0.  ]
 [0.5  0.5  0.5 ]
 [1.   1.   1.  ]]

จากตัวอย่าง ได้สร้างข้อมูลตัวอย่างที่เป็นเมตริกซ์ 3×3 และใช้ MinMaxScaler เพื่อทำการเรียนรู้ช่วงของข้อมูลและแปลงข้อมูลตามช่วงนั้น ซึ่งในที่นี้จะแปลงข้อมูลให้อยู่ในช่วง 0 ถึง 1 ดังนั้นค่าที่แสดงออกมาจะเป็นตัวเลขในช่วงนี้ ตัวอย่างนี้เป็นการแปลงข้อมูลให้อยู่ในช่วงเดียวกันซึ่งเป็นสิ่งที่สำคัญสำหรับการสร้างและฝึกโมเดล Deep Learning โดยทั่วไปเราจะต้องแปลงข้อมูลให้อยู่ในช่วงที่เหมาะสมสำหรับการฝึกโมเดลในการเรียนรู้เชิงลึก

ตัวอย่าง  การแปลงข้อมูล (Data Transformation) สำหรับ Deep Learning ด้วยการใช้งาน TensorFlow

import tensorflow as tf

# โหลดชุดข้อมูล MNIST
mnist = tf.keras.datasets.mnist
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

# แปลงค่าความลึกของสีจากช่วง 0-255 เป็นช่วง 0-1
train_images = train_images / 255.0
test_images = test_images / 255.0

# แปลงรูปภาพจากขนาด 28x28 เป็นเวกเตอร์ขนาด 784
train_images = train_images.reshape(train_images.shape[0], 784)
test_images = test_images.reshape(test_images.shape[0], 784)

# แปลงค่า label เป็น one-hot encoding
train_labels = tf.keras.utils.to_categorical(train_labels, 10)
test_labels = tf.keras.utils.to_categorical(test_labels, 10)

จากตัวอย่าง ได้ใช้ชุดข้อมูล MNIST ที่เป็นชุดข้อมูลที่มีรูปภาพของตัวเลข 0-9 และเรามีการแปลงข้อมูลโดยการแปลงค่าความลึกของสีจากช่วง 0-255 เป็นช่วง 0-1 และแปลงรูปภาพจากขนาด 28×28 เป็นเวกเตอร์ขนาด 784 เพื่อให้ง่ายต่อการประมวลผล ส่วน label จะถูกแปลงเป็น one-hot encoding ซึ่งเป็นการแปลงค่า label เป็นเวกเตอร์ของตัวเลข 0 และ 1 ที่มีความยาวเท่ากับจำนวนคลาสของข้อมูล ในที่นี้คือ 10 คลาส (ตัวเลข 0-9)