Decision Tree ใน Machine Learning ด้วย Python

Decision Tree เป็นอัลกอริทึมที่ใช้ในการเรียนรู้จากข้อมูล โดยเป็นอัลกอริทึมที่ใช้งานง่ายและเป็นที่นิยมในการแก้ไขปัญหาหลายประเภท เช่น งานจัดกลุ่ม (clustering) การแยกประเภท (classification) และการทำนาย (prediction)

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

หลังจากสร้างโมเดล Decision Tree แล้ว สามารถนำโมเดลไปใช้ในการทำนายหรือจัดกลุ่มข้อมูล โดยใช้ข้อมูลที่ไม่เคยเห็นมาก่อน (unseen data) เพื่อให้โมเดลสามารถทำนายหรือจัดกลุ่มข้อมูลได้

การประยุกต์ใช้ Decision Tree ใน Machine Learning มักนำมาใช้ในงานด้านการจัดกลุ่ม แยกประเภท และทำนาย ในหลายๆ งาน เช่น การตัดสินใจในการอนุมัติสินเชื่อ การจัดลำดับความสำคัญของข้อมูล การทำนายอายุผู้ใช้งาน และอื่นๆ 

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

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

ในการสร้าง Decision Tree จะใช้ข้อมูลในการสร้างโมเดล เพื่อให้ Decision Tree สามารถแบ่งข้อมูลออกเป็นกลุ่มย่อย ๆ ได้ ซึ่งการแบ่งข้อมูลจะใช้หลักการของการคัดแยก (Splitting) โดยที่การคัดแยกจะใช้เงื่อนไขของข้อมูล เช่น หากต้องการแบ่งข้อมูลโดยใช้เงื่อนไขว่าอายุมากกว่า 30 ปี จะทำการแบ่งกลุ่มของข้อมูลเป็น 2 กลุ่มคือกลุ่มที่อายุมากกว่า 30 ปีและกลุ่มที่อายุน้อยกว่าหรือเท่ากับ 30 ปี  เป็นต้น

ecision Tree เป็นอัลกอริทึมหนึ่งใน Machine Learning ที่ใช้สำหรับการจัดการกับปัญหาที่เกี่ยวกับการตัดสินใจ โดยมีแนวคิดเหมือนต้นไม้ที่มีราก (root) และสาขา (branch) ส่วนปลายทาง (leaf node) โดยแต่ละ node จะมี feature ที่ใช้ในการตัดสินใจ (splitting criteria) และมีค่า threshold ที่ใช้ในการแบ่งข้อมูลออกเป็นสองส่วน (left child node และ right child node) ตามค่าของ feature นั้นๆ

โดย Decision Tree จะเรียนรู้การตัดสินใจโดยการสร้างโมเดลจากข้อมูล Train set โดยการใช้ feature และ threshold ในการแบ่งข้อมูลออกเป็นกลุ่ม ๆ จนกว่าจะได้ leaf node โดยในแต่ละ leaf node จะมีค่า output หรือค่าที่เราต้องการ predict สำหรับแต่ละกรณี

ในการ predict ข้อมูลใหม่ Decision Tree จะนำ feature ของข้อมูลใหม่ไปวิเคราะห์และเลือกใช้ feature ในการแบ่งข้อมูลตาม node ต่าง ๆ จนกว่าจะได้ leaf node แล้วใช้ค่า output ใน leaf node นั้น ๆ ในการทำนายผลลัพธ์

Decision Tree เป็นอัลกอริทึมที่ง่ายต่อการทำนายและตรวจสอบเหมาะสมสำหรับข้อมูลที่มี feature ไม่มากนัก และมีความชัดเจนในการแบ่งกลุ่ม โดย Decision Tree มักใช้ในงานด้าน Business Intelligence หรือ Marketing Analytics เพื่อการวิเคราะห์และสร้างโมเดลในการตัดสินใจธุรกิจ หรือการทำนายพฤติกรรมลูกค้าเป็นต้น

ขั้นตอนในการสร้าง Decision Tree

ใน Machine Learning ประกอบด้วยขั้นตอนดังนี้

1. ตั้งคำถาม (Question) เพื่อหา Node ต้นแบบ (Root Node) ที่สามารถแยกข้อมูลได้ดีที่สุด โดยคำถามต้องเป็นคำถามที่เกี่ยวข้องกับตัวแปรที่ต้องการจะทำนาย (Target Variable) และสามารถแยกข้อมูลออกเป็นกลุ่มได้ชัดเจน

2. นำข้อมูลเข้าไปใน Root Node และแบ่งข้อมูลออกเป็นกลุ่มโดยใช้คำถามที่ถามใน Root Node

3. สร้าง Node ลูก (Child Node) จากการแบ่งข้อมูล โดยต้องพิจารณาว่าการแบ่งต้องทำให้ข้อมูลในแต่ละกลุ่มมีความสมดุลกันและมีค่า Information Gain สูง

4. ทำซ้ำขั้นตอนที่ 2-3 สำหรับแต่ละ Child Node จนกว่าจะไม่สามารถแบ่งข้อมูลได้อีก

5. หยุดการแบ่งข้อมูลเมื่อเงื่อนไขหยุด (Stopping Condition) ถูกต้อง เช่น จำนวนข้อมูลใน Node น้อยกว่าเท่าไหร่ หรือความลึกของ Tree มากเกินไป

6. ใช้ Decision Tree ที่ได้สร้างขึ้นมาในการทำนายผลลัพธ์สำหรับข้อมูลใหม่ที่ยังไม่เคยมีในการ Train Model

7. ประเมินประสิทธิภาพของ Decision Tree โดยใช้ Metrics เช่น Accuracy, Precision, Recall หรือ F1-Score เป็นต้น

Decision Tree เป็นอัลกอริทึมสำหรับ supervised learning ใน Machine Learning ซึ่งใช้สำหรับการจัดการข้อมูลที่มีการตัดสินใจหลายทางเพื่อหาคำตอบที่เหมาะสม โดยแบ่งข้อมูลออกเป็นกลุ่มย่อยๆ จนกว่าจะได้กลุ่มย่อยที่มีขนาดเล็กพอที่จะทำการทำนายหรือจัดสรรค่า target ให้กับข้อมูลใหม่

การใช้งาน Decision Tree

ใน Machine Learning สามารถนำไปใช้งานได้หลายรูปแบบ เช่น

1. Classification: การจัดกลุ่มข้อมูลออกเป็นกลุ่มย่อยๆ โดยที่กลุ่มย่อยแต่ละกลุ่มจะมีคลาสเป้าหมายเดียวกัน

2. Regression: การทำนายค่าต่อเนื่อง โดยจะแบ่งข้อมูลเป็นช่วงค่าและทำนายค่าต่อเนื่องในแต่ละช่วง

3. Multi-output: การทำนายหลายค่าเป้าหมายพร้อมกัน

4. Feature Selection: การเลือก Feature ที่สำคัญที่สุดในการทำนายผล

5. Anomaly detection: การตรวจสอบค่าผิดปกติหรือ Outlier ในข้อมูล

6. Clustering: การจัดกลุ่มข้อมูลออกเป็นกลุ่มย่อยๆ โดยไม่ต้องระบุคลาสเป้าหมาย

7. Reinforcement Learning: การสร้างกฎการตัดสินใจในการทำงานของ Agent ให้เหมาะสม

การนำ Decision Tree มาใช้งานในแต่ละรูปแบบนี้จะต้องมีการปรับแต่งพารามิเตอร์ต่างๆ ของ Decision Tree Algorithm ให้เหมาะสมกับงานที่ต้องการทำ และอาจจะต้องนำ Decision Tree มาใช้งานร่วมกับ Algorithm อื่นๆ

ตัวอย่าง การใช้ Decision Tree ใน Python เพื่อทำนายการเลือกของลูกค้าในการซื้อสินค้าออนไลน์

import pandas as pd
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, confusion_matrix

# โหลดข้อมูล
url = 'https://kittimasak.com/data/shoppers_intention_kittimasak.csv'
df = pd.read_csv(url)

# แปลงคอลัมน์ตัวอักษรเป็นตัวเลขโดยใช้ Label Encoding
from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
df['VisitorType'] = le.fit_transform(df['VisitorType'])

# แบ่งข้อมูลเป็น Features และ Target
X = df.drop('Revenue', axis=1)
y = df['Revenue']

# แบ่งข้อมูลเป็น Train set และ Test set
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1)

# สร้าง Decision Tree Model
dtc = DecisionTreeClassifier()

# Train Model
dtc.fit(X_train, y_train)

# ทำนายผล
y_pred = dtc.predict(X_test)

# คำนวณค่าความแม่นยำ
accuracy = accuracy_score(y_test, y_pred)
print("Accuracy:", accuracy)

# แสดงผลการทำนายโดยใช้ Confusion Matrix
conf_matrix = confusion_matrix(y_test, y_pred)
print("Confusion Matrix:\n", conf_matrix)

ผลลัพธ์ที่ได้จากการทำนายและวัดผลความแม่นยำของ Decision Tree Model ดังนี้

Accuracy: 0.8829311678398829
Confusion Matrix:
[[2839 270]
[ 244 356]]

จากตัวอย่าง ได้ใช้ Decision Tree ในการทำนายว่าลูกค้าจะเลือกซื้อสินค้าหรือไม่จากข้อมูลออนไลน์ของลูกค้า เราได้ทำการแปลงคอลัมน์ VisitorType เป็นตัวเลขโดยใช้ Label Encoding ก่อนที่จะแบ่งข้อมูลเป็น Train set และ Test set และสร้าง Decision Tree Model โดยใช้ DecisionTreeClassifier() จากนั้นทำการ Train Model โดยใช้ fit() กับ Train set และทำนายผลโดยใช้ predict() กับ Test set สุดท้ายเราได้ทำการคำนวณค่าความแม่นยำและแสดงผลการทำนายโดยใช้ Confusion Matrix

ตัวอย่าง การใช้ Decision Tree ใน Python โดยสร้างขึ้นมาด้วยคลาส plot_tree จากไลบรารี sklearn

import numpy as np
from sklearn.tree import DecisionTreeClassifier, plot_tree
import matplotlib.pyplot as plt

# สร้างข้อมูล
X = np.array([[0,0], [0,1], [1,0], [1,1]])
y = np.array([0, 1, 1, 0])

# สร้าง Decision Tree Model
dtc = DecisionTreeClassifier()
dtc.fit(X, y)

# แสดงกราฟ Decision Tree
plt.figure(figsize=(5, 3))
plot_tree(dtc, filled=True)
plt.show()

ผลลัพธ์ที่ได้คือความสัมพ้นธ์ของต้นไม้ Decision Tree ที่สร้างขึ้นมา

จากตัวอย่างในกรณีนี้ สองคอลัมน์แรกของ X แทนค่า input และคอลัมน์ y แทน output ที่เราต้องการจะทำนาย โดยจะมีค่าเป็น 0 หรือ 1 ซึ่งเป็นผลลัพธ์ของการ XOR ของ input 2 ตัว ตัวอย่างนี้เป็นตัวอย่างที่แสดงให้เห็นถึงวิธีการสร้างต้นไม้ Decision Tree ด้วยคลาส DecisionTreeClassifier และการแสดงผลด้วย plot_tree จาก sklearn.tree

มีการใช้ Decision Tree Classifier กับข้อมูลจำนวนมากสุด 4 ตัวอย่าง โดย X เป็น numpy array ที่เก็บ feature ของแต่ละตัวอย่าง และ y เป็น numpy array ที่เก็บ class label ของแต่ละตัวอย่าง โดย class label มีค่าเป็น 0 หรือ 1

ตัวอย่าง การใช้ Decision Tree

import numpy as np
import matplotlib.pyplot as plt
from sklearn.tree import DecisionTreeClassifier, plot_tree
from sklearn.datasets import make_classification

# สร้างข้อมูล
X, y = make_classification(n_features=4, n_redundant=0, n_informative=2, random_state=42)

# สร้าง Decision Tree Model
dtc = DecisionTreeClassifier(max_depth=3, random_state=42)
dtc.fit(X, y)

# แสดงกราฟ Decision Tree
plt.figure(figsize=(10, 6))
plot_tree(dtc, filled=True, rounded=True, feature_names=["Feature 1", "Feature 2", "Feature 3", "Feature 4"], class_names=["Class 0", "Class 1"])
plt.show()

ผลลัพธ์ที่ได้คือกราฟ Decision Tree ดังนี้

จาดตัวอย่าง เป็นการใช้ Decision Tree ในการสร้างและแสดงผลต้นไม้ในรูปแบบกราฟ โดยมีรายละเอียดดังนี้

1. สร้างข้อมูลด้วยฟังก์ชัน make_classification โดยกำหนดพารามิเตอร์ต่างๆ เช่น จำนวน feature, จำนวน class, ความซับซ้อนของข้อมูล เป็นต้น ในตัวอย่างนี้กำหนดให้มี 4 features และมี 2 classes

2. สร้าง Decision Tree Model โดยกำหนดพารามิเตอร์ max_depth และ random_state เพื่อควบคุมความลึกของต้นไม้และการสุ่มข้อมูล

3. แสดงผลกราฟ Decision Tree โดยใช้ฟังก์ชัน plot_tree โดยกำหนดพารามิเตอร์ต่างๆ เช่น filled เพื่อให้โหนดต่างๆ มีสีตามคลาส, rounded เพื่อให้รูปแบบของโหนดเป็นรูปกลม, feature_names เพื่อกำหนดชื่อ features และ class_names เพื่อกำหนดชื่อคลาส

4. แสดงผลกราฟ Decision Tree ผ่าน matplotlib ด้วยฟังก์ชัน show()

จากการใช้ Decision Tree ในการแบ่งแยกคลาสของข้อมูลที่สุ่มมาจากฟังก์ชัน make_classification โดยมีจำนวน feature ทั้งหมด 4 และมี feature ที่มีข้อมูลไม่จำเป็นอยู่ 0 feature และ feature ที่เป็น informative 2 feature โดยมี class ทั้งหมด 2 คลาส คือ Class 0 และ Class 1

โมเดล Decision Tree ที่สร้างขึ้นมาจะมีความลึกไม่เกิน 3 ชั้น (max_depth=3) โดยการแบ่งตาม feature ที่สร้างขึ้นโดยตั้งชื่อ feature ดังนี้ Feature 1, Feature 2, Feature 3 และ Feature 4 และคลาสที่แบ่งแยกอยู่ 2 คลาส คือ Class 0 และ Class 1

ผลลัพธ์ที่แสดงออกมาคือกราฟ Decision Tree ที่แสดงวิธีการแบ่งแยกข้อมูลในการตัดสินใจโดยใช้ค่า threshold ของ feature ต่างๆ และแบ่งแยกเป็นสองกลุ่ม (leaf) ซึ่งแต่ละ leaf จะมีคลาสที่แตกต่างกัน ตามที่โมเดล Decision Tree ได้เรียนรู้แล้วจากข้อมูลที่ให้มาในการสร้างโมเดล

ตัวอย่าง การใช้ Decision Tree เพื่อวิเคราะห์ความสัมพันธ์ระหว่างตัวแปรต้น (features) กับตัวแปรเป้าหมาย (target variable) ในกรณีขายสินค้าออนไลน์ โดยสร้างข้อมูลขึ้นมาเอง และแสดงกราฟ Decision Tree ที่ได้รับการสร้างจากข้อมูลนี้

import numpy as np
import matplotlib.pyplot as plt
from sklearn.tree import DecisionTreeClassifier, plot_tree

# สร้างข้อมูลตัวอย่าง
n_samples = 1000
X = np.random.rand(n_samples, 3)
y = np.zeros(n_samples)
y[np.logical_and(X[:, 0] < 0.5, X[:, 1] > 0.5)] = 1
y[np.logical_and(X[:, 0] > 0.5, X[:, 2] > 0.5)] = 1

# สร้าง Decision Tree Model
dtc = DecisionTreeClassifier(max_depth=3, random_state=42)
dtc.fit(X, y)

# แสดงกราฟ Decision Tree
plt.figure(figsize=(10, 6))
plot_tree(dtc, filled=True, rounded=True, feature_names=["Product Quality", "Price", "Delivery Time"], class_names=["No Sale", "Sale"])
plt.show()

ผลลัพธ์ที่ได้ คือ

จากตัวอย่าง มีการใช้ Decision Tree Classifier เพื่อทำนายว่าลูกค้าจะซื้อสินค้าในเว็บไซต์ของร้านค้าหรือไม่ โดยใช้ข้อมูลจำลองที่สร้างขึ้นมาเอง โดยมีข้อมูลประกอบด้วย 6 features และ target 1 ตัว โดยรายละเอียดการทำงานของโค้ด คือ

1. สร้างข้อมูลจำลอง (simulated data) ที่มี 6 ตัวแปร (features) โดยใช้ฟังก์ชัน make_classification() จาก sklearn.datasets โดยกำหนด n_samples=1000 (จำนวนข้อมูล), n_features=6 (จำนวน features), n_informative=4 (จำนวน features ที่มีความสำคัญ), n_redundant=0 (จำนวน features ที่ซ้ำกัน), random_state=42 (random seed เพื่อให้ผลการสุ่มเหมือนกัน)

2. แบ่งข้อมูลเป็น train set และ test set โดยใช้ฟังก์ชัน train_test_split() จาก sklearn.model_selection โดยกำหนด test_size=0.3 (สัดส่วนของ test set คือ 30%) และ random_state=42

3. สร้าง Decision Tree Model โดยใช้ DecisionTreeClassifier() จาก sklearn.tree โดยกำหนด max_depth=5 (ความลึกของต้นไม้) และ random_state=42 (random seed เพื่อให้ผลการสุ่มเหมือนกัน)

4. Train model โดยใช้ฟังก์ชัน fit() จาก DecisionTreeClassifier() โดยให้โมเดลเรียนรู้จากข้อมูล train set (X_train, y_train)

5. ทำนายผลจากข้อมูล test set (X_test) โดยใช้ฟังก์ชัน predict() จาก DecisionTreeClassifier()

6. คำนวณค่าความแม่นยำของโมเดลโดยใช้ accuracy_score() จาก sklearn.metrics และแสดงผลค่าความแม่นยำ

7. แสดงกราฟ Decision Tree โดยใช้ฟังก์ชัน plot_tree() จาก sklearn.tree

การใช้ Decision Tree ในงานที่เกี่ยวกับการขายสินค้าออนไลน์ โดยสร้างข้อมูลขึ้นมาจำนวน 1000 ตัว ที่ประกอบด้วย Features 3 ตัว ได้แก่ Product Quality, Price และ Delivery Time โดยให้มีค่าอยู่ระหว่าง 0-1 และตัดสินใจที่จะซื้อสินค้าโดยเอา Price และ Delivery Time มาเปรียบเทียบกับค่ากลางคือ 0.5 โดยถ้า Price < 0.5 และ Delivery Time > 0.5 จะเป็นผู้ซื้อ หรือถ้า Price > 0.5 และ Delivery Time > 0.5 จะเป็นผู้ซื้อด้วย โดยที่ Product Quality ไม่มีผลต่อการตัดสินใจของผู้ซื้อ จากนั้นสร้าง Decision Tree Model โดยกำหนด max_depth เท่ากับ 3 และ random_state เท่ากับ 42 และทำการ fit กับข้อมูล X, y สุดท้ายแสดงผลกราฟ Decision Tree ที่ได้จากการ train ด้วยฟังก์ชัน plot_tree() โดยกำหนดชื่อ Feature และ Class ของ Decision Tree ตามลำดับว่าคืออะไร ซึ่งจะช่วยให้ผู้อ่านเข้าใจได้ง่ายขึ้น