Week 3: Introduction to Machine Learning & Classification

🎯 บทนำ: ทำไมเครื่องต้องเรียนรู้?

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

Machine Learning ก็ทำงานแบบเดียวกัน - เราให้ตัวอย่างข้อมูลกับคอมพิวเตอร์ แล้วให้มันเรียนรู้หารูปแบบ (patterns) เอง

📚 1. Machine Learning Fundamentals

1.1 นิยามของ Machine Learning

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

🤔 ทำไมต้องใช้ Machine Learning?

1. ปัญหาที่ซับซ้อนเกินกว่าจะเขียนกฎ

จดจำใบหน้า - มีรายละเอียดมากเกินกว่าจะเขียน if-else
แปลภาษา - มีข้อยกเว้นและบริบทมากมาย

2. ปัญหาที่เปลี่ยนแปลงตลอดเวลา

กรองสแปม - spammer คิดวิธีใหม่ๆ ตลอด
แนะนำสินค้า - ความชอบของลูกค้าเปลี่ยนตามกาลเวลา

3. ปัญหาที่มนุษย์ทำได้แต่อธิบายไม่ได้

แยกเสียงพูดในที่มีเสียงรบกวน
อ่านลายมือหมอ

1.2 ประเภทของการเรียนรู้

🏷️ 1. Supervised Learning (การเรียนรู้แบบมีผู้สอน)

เหมือนการเรียนที่มีครูคอยบอกคำตอบ

ลักษณะสำคัญ

มีข้อมูลตัวอย่างพร้อมคำตอบ (labeled data)
เรียนรู้ความสัมพันธ์ระหว่าง input และ output
ใช้ทำนายคำตอบสำหรับข้อมูลใหม่

ตัวอย่าง

ตัวอย่าง
Input: รูปภาพ → Output: "แมว" หรือ "สุนัข"
Input: อีเมล → Output: "สแปม" หรือ "ไม่ใช่สแปม"
Input: ขนาดบ้าน → Output: ราคาบ้าน

แบ่งเป็น 2 ประเภทย่อย

Classification ทำนายหมวดหมู่ (แมว/สุนัข, ผ่าน/ไม่ผ่าน)
Regression ทำนายค่าตัวเลข (ราคา, อุณหภูมิ, คะแนน)

🔍 2. Unsupervised Learning (การเรียนรู้แบบไม่มีผู้สอน)

เหมือนการให้เด็กจัดกลุ่มของเล่นเอง โดยไม่บอกว่าจัดยังไง

ลักษณะสำคัญ:

ไม่มีคำตอบให้ (unlabeled data)
หารูปแบบหรือโครงสร้างในข้อมูลเอง
ใช้สำรวจและทำความเข้าใจข้อมูล

ตัวอย่าง

ตัวอย่าง
- จัดกลุ่มลูกค้าตามพฤติกรรมการซื้อ (Clustering)
- ลดมิติข้อมูลเพื่อ visualization (Dimensionality Reduction)
- หา anomaly ในระบบ (Anomaly Detection)

🎮 3. Reinforcement Learning (การเรียนรู้แบบเสริมกำลัง)

เหมือนการฝึกสุนัขด้วยการให้รางวัลและลงโทษ

ลักษณะสำคัญ:

เรียนรู้จากการลองผิดลองถูก
ได้รับ reward หรือ punishment จากการกระทำ
ปรับปรุงกลยุทธ์เพื่อให้ได้ reward สูงสุด

ตัวอย่าง

ตัวอย่าง
- AI เล่นเกม (AlphaGo, OpenAI Five)
- หุ่นยนต์เดิน
- ระบบแนะนำที่ปรับตัวตามการตอบสนองของผู้ใช้

1.3 การแบ่งข้อมูลสำหรับ Machine Learning

🎯 ทำไมต้องแบ่งข้อมูล?

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

Machine Learning ก็เช่นกัน เราต้องทดสอบด้วยข้อมูลที่โมเดลไม่เคยเห็น

📊 การแบ่งข้อมูล 3 ส่วน

ข้อมูลทั้งหมด (100%)
    │
    ├─── Training Set (60-70%)
    │    └── ใช้สอนโมเดล
    │
    ├─── Validation Set (15-20%)
    │    └── ใช้ปรับแต่ง hyperparameters
    │
    └─── Test Set (15-20%)
         └── ใช้ประเมินผลสุดท้าย

1. Training Set (ชุดฝึก)

ข้อมูลที่ใช้สอนโมเดล
เหมือนแบบฝึกหัดในหนังสือเรียน
โมเดลจะปรับตัวให้เรียนรู้จากข้อมูลชุดนี้

2. Validation Set (ชุดตรวจสอบ)

ใช้ระหว่างการฝึก เพื่อดูว่าโมเดลเรียนรู้ได้ดีแค่ไหน
ช่วยเลือก hyperparameters ที่เหมาะสม
เหมือนแบบทดสอบย่อยระหว่างเรียน

3. Test Set (ชุดทดสอบ)

ใช้ครั้งเดียวหลังฝึกเสร็จ
ประเมินผลงานจริงของโมเดล
เหมือนข้อสอบปลายภาค

💡 Best Practices

สุ่มข้อมูลก่อนแบ่ง - ป้องกันความเอนเอียง
รักษาสัดส่วนของแต่ละ class - ใช้ stratified sampling
ไม่แอบดู test set - ดูแล้วเท่ากับโกง!

1.4 Overfitting และ Underfitting

🎭 Overfitting (เรียนรู้มากเกินไป)

อะไรคือ Overfitting?

โมเดลจำรายละเอียดของ training data มากเกินไป
ทำนาย training data ได้แม่นยำมาก แต่ทำนายข้อมูลใหม่ได้แย่
เหมือนนักเรียนที่จำคำตอบแต่ไม่เข้าใจหลักการ

สาเหตุ

โมเดลซับซ้อนเกินไป
ข้อมูลฝึกน้อยเกินไป
ฝึกนานเกินไป

วิธีแก้

ลดความซับซ้อนของโมเดล
เพิ่มข้อมูลฝึก
ใช้ regularization
ใช้ dropout (สำหรับ neural networks)
Early stopping

🤷 Underfitting (เรียนรู้น้อยเกินไป)

อะไรคือ Underfitting?

โมเดลง่ายเกินไปจนจับ patterns สำคัญไม่ได้
ทำนายได้แย่ทั้ง training และ test data
เหมือนพยายามใช้เส้นตรงอธิบายข้อมูลที่เป็นเส้นโค้ง

สาเหตุ:

โมเดลง่ายเกินไป
features ไม่เพียงพอ
ฝึกน้อยเกินไป

วิธีแก้:

เพิ่มความซับซ้อนของโมเดล
เพิ่ม features
ฝึกนานขึ้น
ลด regularization

⚖️ การหาจุดสมดุล

Underfitting          Just Right          Overfitting
     |                    |                    |
  Too Simple      Balanced Model        Too Complex
  High Bias         Low Bias           High Variance
                   Low Variance

🎯 2. Classification Algorithms พื้นฐาน

2.1 k-Nearest Neighbors (k-NN)

🏘️ หลักการทำงาน

k-NN ทำงานตามหลักการง่ายๆ: "บอกฉันว่าคุณคบใครเป็นเพื่อน แล้วฉันจะบอกว่าคุณเป็นคนแบบไหน"

ขั้นตอน

เมื่อต้องการจำแนกข้อมูลใหม่
หาข้อมูลที่ใกล้เคียงที่สุด k ตัว
ดูว่าเพื่อนบ้านส่วนใหญ่อยู่ class ไหน
จัดข้อมูลใหม่ไปอยู่ class นั้น

📐 การวัดระยะทาง

🎯 การวัดระยะทาง 2 แบบ

Euclidean (เส้นตรง)

Manhattan (แนวตั้ง+แนวนอน)

1. Euclidean Distance

d = √[(x₁-x₂)² + (y₁-y₂)²]

ใช้บ่อยที่สุด
เหมือนวัดระยะทางเส้นตรงบนแผนที่

2. Manhattan Distance

d = |x₁-x₂| + |y₁-y₂|

เหมือนเดินในเมืองที่มีแต่ถนนตัดกันเป็นตาราง
เหมาะกับข้อมูลที่ features มีหน่วยต่างกัน

3. Cosine Similarity

วัดมุมระหว่าง vectors
เหมาะกับข้อมูลข้อความหรือข้อมูลมิติสูง

🎛️ การเลือกค่า k

ค่า k	ข้อดี	ข้อเสีย
k น้อย (เช่น k=1)	✅ ไวต่อข้อมูล (sensitive)	❌ ไวต่อ noise มาก ❌ decision boundary ขรุขระ
k มาก (เช่น k=จำนวนข้อมูลทั้งหมด)	✅ ทนต่อ noise	❌ อาจ underfit ❌ decision boundary เรียบเกินไป

หลักการเลือก k

ใช้เลขคี่เพื่อหลีกเลี่ยงการเสมอ
ทดลองหลายค่าแล้วดูจาก validation accuracy
k ที่นิยม: 3, 5, 7

💻 ตัวอย่าง Code

from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

# เตรียมข้อมูล
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# ปรับ scale (สำคัญมากสำหรับ k-NN!)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# สร้างและฝึกโมเดล
knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train_scaled, y_train)

# ทำนาย
predictions = knn.predict(X_test_scaled)

⚡ ข้อดีและข้อเสีย

✅ ข้อดี

เข้าใจง่าย อธิบายได้
ไม่ต้อง train (lazy learning)
ทำงานได้ดีกับข้อมูลที่มี decision boundary ซับซ้อน

❌ ข้อเสีย

ช้าเมื่อข้อมูลเยอะ (ต้องคำนวณระยะทางทุกครั้ง)
ใช้หน่วยความจำมาก (ต้องเก็บข้อมูลทั้งหมด)
ไวต่อ scale ของ features
ไม่ดีกับข้อมูลมิติสูง (curse of dimensionality)

2.2 Decision Trees (ต้นไม้ตัดสินใจ)

🌳 หลักการทำงาน

Decision Tree ทำงานเหมือนเกม 20 คำถาม - ถามคำถามทีละข้อเพื่อแบ่งข้อมูลจนได้คำตอบ

ตัวอย่าง: แยกผลไม้

                 สีเหลือง?
                /        \
              ใช่         ไม่
              /            \
        ขนาดใหญ่?         สีแดง?
        /      \         /     \
      ใช่      ไม่      ใช่     ไม่
      /         \       /       \
   แตงโม      กล้วย   แอปเปิล   ส้ม

📊 การสร้างต้นไม้

เลือก feature ที่ดีที่สุดสำหรับแบ่ง
- ใช้ Information Gain หรือ Gini Impurity
- เลือก feature ที่ทำให้ข้อมูลหลังแบ่ง "บริสุทธิ์" ที่สุด
แบ่งข้อมูลตาม feature นั้น
- ถ้าเป็น categorical: แบ่งตามค่า
- ถ้าเป็น numerical: หาจุดตัด (threshold)
ทำซ้ำจนกว่าจะ
- ทุก node บริสุทธิ์ (มีแต่ class เดียว)
- ถึงความลึกที่กำหนด
- จำนวนข้อมูลใน node น้อยกว่าที่กำหนด

🎯 Metrics สำหรับเลือก Feature

1. Information Gain (based on Entropy)

Entropy = -Σ(p_i × log₂(p_i))
Information Gain = Entropy(parent) - Σ(weighted Entropy(children))

Entropy วัดความไม่แน่นอน (uncertainty)
ยิ่ง entropy ต่ำ = ข้อมูลยิ่งบริสุทธิ์
เลือก feature ที่ให้ Information Gain สูงสุด

2. Gini Impurity

Gini = 1 - Σ(p_i²)

วัดความไม่บริสุทธิ์
คำนวณเร็วกว่า entropy
ให้ผลใกล้เคียงกัน

🌿 การ Pruning (ตัดแต่งต้นไม้)

Pre-pruning (ป้องกันไว้ก่อน)

จำกัดความลึกสูงสุด (max_depth)
กำหนดจำนวนข้อมูลขั้นต่ำใน node (min_samples_split)
กำหนดจำนวนข้อมูลขั้นต่ำใน leaf (min_samples_leaf)

Post-pruning (ตัดทีหลัง)

สร้างต้นไม้เต็มที่ก่อน
ตัด subtrees ที่ไม่ช่วยเพิ่มประสิทธิภาพ
ใช้ validation set ในการตัดสินใจ

💻 ตัวอย่าง Code:

from sklearn.tree import DecisionTreeClassifier
from sklearn.tree import plot_tree
import matplotlib.pyplot as plt

# สร้างโมเดล
dt = DecisionTreeClassifier(
    max_depth=5,           # ความลึกสูงสุด
    min_samples_split=20,  # จำนวนข้อมูลขั้นต่ำที่จะแบ่ง
    min_samples_leaf=10    # จำนวนข้อมูลขั้นต่ำใน leaf
)

# ฝึกโมเดล
dt.fit(X_train, y_train)

# วาดต้นไม้
plt.figure(figsize=(20,10))
plot_tree(dt, feature_names=feature_names, 
          class_names=class_names, filled=True)
plt.show()

# ดู feature importance
importances = dt.feature_importances_
for i, importance in enumerate(importances):
    print(f"{feature_names[i]}: {importance:.3f}")

⚡ ข้อดีและข้อเสีย

✅ ข้อดี:

เข้าใจและอธิบายง่าย (interpretable)
ไม่ต้อง scale ข้อมูล
จัดการได้ทั้ง numerical และ categorical
ให้ feature importance

❌ ข้อเสีย:

เสี่ยง overfitting ง่าย
ไม่เสถียร (ข้อมูลเปลี่ยนนิดเดียวต้นไม้เปลี่ยนมาก)
ไม่เก่งกับความสัมพันธ์เชิงเส้น
Bias ไปทาง features ที่มีค่าเยอะ

2.3 Naive Bayes

🎲 หลักการทำงาน

Naive Bayes ใช้ทฤษฎีความน่าจะเป็นของ Bayes ในการจำแนกประเภท

Bayes' Theorem

P(class|features) = P(features|class) × P(class) / P(features)

แปลเป็นภาษาคน

ความน่าจะเป็นที่จะเป็น class นั้น เมื่อเห็น features เหล่านี้
= ความน่าจะเป็นที่จะเจอ features เหล่านี้ใน class นั้น
× ความน่าจะเป็นของ class นั้นโดยทั่วไป
÷ ความน่าจะเป็นที่จะเจอ features เหล่านี้

🤝 สมมติฐาน "Naive"

ทำไมถึงเรียกว่า "Naive" (ซื่อ)?

สมมติว่าทุก feature เป็นอิสระต่อกัน
ในความเป็นจริงอาจไม่จริง แต่ก็ยังทำงานได้ดี!

ตัวอย่าง

ในการแยกสแปม สมมติว่า

การมีคำว่า "ฟรี"
การมีคำว่า "โปรโมชั่น"
ไม่เกี่ยวข้องกัน (ซึ่งจริงๆ มักปรากฏด้วยกัน)

📈 ประเภทของ Naive Bayes

1. Gaussian Naive Bayes

ใช้กับ features ที่เป็นตัวเลขต่อเนื่อง
สมมติว่าข้อมูลมีการกระจายแบบ normal

2. Multinomial Naive Bayes

ใช้กับข้อมูลที่เป็นการนับ (เช่น จำนวนคำ)
เหมาะกับ text classification

3. Bernoulli Naive Bayes

ใช้กับข้อมูล binary (มี/ไม่มี)
เหมาะกับ features ที่เป็น boolean

💻 ตัวอย่าง Code:

from sklearn.naive_bayes import GaussianNB, MultinomialNB
from sklearn.feature_extraction.text import CountVectorizer

# สำหรับข้อมูลตัวเลข
gnb = GaussianNB()
gnb.fit(X_train, y_train)

# สำหรับข้อความ
vectorizer = CountVectorizer()
X_text = vectorizer.fit_transform(text_data)
mnb = MultinomialNB()
mnb.fit(X_text, y_labels)

# ดูความน่าจะเป็น
proba = gnb.predict_proba(X_test)
print(f"ความน่าจะเป็นของแต่ละ class: {proba}")

⚡ ข้อดีและข้อเสีย

✅ ข้อดี:

เร็วมาก ทั้ง train และ predict
ใช้ข้อมูลน้อยก็ทำงานได้
ทำงานดีกับข้อมูลมิติสูง
ทนต่อ irrelevant features

❌ ข้อเสีย:

สมมติฐาน independence อาจไม่จริง
ไม่จับความสัมพันธ์ระหว่าง features
Zero frequency problem (ต้องใช้ smoothing)
ค่าความน่าจะเป็นอาจไม่ calibrated ดี

📊 3. Model Evaluation

3.1 Confusion Matrix

🎯 อะไรคือ Confusion Matrix?

ตารางที่แสดงผลการทำนายเทียบกับคำตอบจริง ช่วยให้เห็นว่าโมเดลสับสนตรงไหน

สำหรับ Binary Classification

                 Predicted
                 Positive  Negative
Actual Positive    TP       FN
       Negative    FP       TN

TP = True Positive  (ทายถูกว่าใช่)
TN = True Negative  (ทายถูกว่าไม่ใช่)
FP = False Positive (ทายผิดว่าใช่ - Type I Error)
FN = False Negative (ทายผิดว่าไม่ใช่ - Type II Error)

ตัวอย่าง: ตรวจโรค

                  Predicted
                  มีโรค   ไม่มีโรค
Actual มีโรค       85      15     (มีโรค 100 คน)
       ไม่มีโรค     20      880    (ไม่มีโรค 900 คน)

3.2 Metrics การวัดประสิทธิภาพ

📏 1. Accuracy (ความแม่นยำโดยรวม)

Accuracy = (TP + TN) / (TP + TN + FP + FN)

เมื่อไหร่ใช้ได้ดี

ข้อมูลแต่ละ class มีจำนวนใกล้เคียงกัน
ผลกระทบของการทำนายผิดแต่ละแบบเท่ากัน

เมื่อไหร่ไม่ควรใช้

Imbalanced data (เช่น โรคหายาก 1:1000)
ต้นทุนการผิดพลาดต่างกัน

🎯 2. Precision (ความแม่นยำเมื่อทายว่าใช่)

Precision = TP / (TP + FP)

"ในสิ่งที่ทายว่าใช่ มีกี่อันที่ใช่จริง?"

ใช้เมื่อ

FP มีต้นทุนสูง
เช่น ระบบกรองสแปม (ไม่อยาก block อีเมลดีๆ)

🔍 3. Recall/Sensitivity (ความสามารถหาของจริง)

Recall = TP / (TP + FN)

"ในของจริงทั้งหมด หาเจอกี่อัน?"

ใช้เมื่อ:

FN มีต้นทุนสูง
เช่น ตรวจมะเร็ง (ไม่อยากพลาดคนป่วย)

⚖️ 4. F1-Score (ค่าเฉลี่ยแบบถ่วงน้ำหนัก)

F1 = 2 × (Precision × Recall) / (Precision + Recall)

ใช้เมื่อ:

ต้องการความสมดุลระหว่าง Precision และ Recall
ข้อมูล imbalanced

📊 5. สำหรับ Multi-class Classification

Macro Average

คำนวณ metric แต่ละ class แล้วเฉลี่ย
ให้น้ำหนักทุก class เท่ากัน

Weighted Average

ถ่วงน้ำหนักตามจำนวนข้อมูลแต่ละ class
เหมาะกับ imbalanced data

Micro Average

รวม TP, FP, FN ของทุก class แล้วคำนวณ
ให้น้ำหนักทุกตัวอย่างเท่ากัน

3.3 Cross-validation

🔄 ทำไมต้องใช้ Cross-validation?

ปัญหาของการแบ่งข้อมูลครั้งเดียว

อาจโชคดี/โชคร้ายในการสุ่ม
ใช้ข้อมูลไม่คุ้ม (test set ไม่ได้ใช้ train)

📋 k-Fold Cross-validation

ขั้นตอน

แบ่งข้อมูลเป็น k ส่วนเท่าๆ กัน (folds)
ใช้ 1 fold เป็น validation, ที่เหลือเป็น training
ทำซ้ำ k รอบ โดยสลับ fold
เฉลี่ยผลลัพธ์

รอบที่ 1: [Valid] [Train] [Train] [Train] [Train]
รอบที่ 2: [Train] [Valid] [Train] [Train] [Train]
รอบที่ 3: [Train] [Train] [Valid] [Train] [Train]
รอบที่ 4: [Train] [Train] [Train] [Valid] [Train]
รอบที่ 5: [Train] [Train] [Train] [Train] [Valid]

🎲 Variations ของ Cross-validation

1. Stratified k-Fold

รักษาสัดส่วนของแต่ละ class ในทุก fold
จำเป็นสำหรับ imbalanced data

2. Leave-One-Out (LOO)

k = จำนวนข้อมูลทั้งหมด
แม่นยำมากแต่ช้ามาก
เหมาะกับข้อมูลน้อย

3. Time Series Split

สำหรับข้อมูลที่มีลำดับเวลา
Train ด้วยข้อมูลอดีต, test ด้วยอนาคต

💻 ตัวอย่าง Code:

from sklearn.model_selection import cross_val_score, StratifiedKFold
from sklearn.metrics import classification_report, confusion_matrix

# Cross-validation
cv_scores = cross_val_score(model, X, y, cv=5, scoring='accuracy')
print(f"CV Accuracy: {cv_scores.mean():.3f} (+/- {cv_scores.std()*2:.3f})")

# Stratified k-fold สำหรับ imbalanced data
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores = cross_val_score(model, X, y, cv=skf, scoring='f1_weighted')

# หลังจาก train model แล้ว
y_pred = model.predict(X_test)

# Confusion Matrix
cm = confusion_matrix(y_test, y_pred)
print("Confusion Matrix:")
print(cm)

# Classification Report
print("\nClassification Report:")
print(classification_report(y_test, y_pred))

🎯 4. การเลือก Algorithm ที่เหมาะสม

📊 ปัจจัยในการพิจารณา

1. ขนาดข้อมูล

น้อย → Naive Bayes, Decision Tree
ปานกลาง → k-NN, SVM
มาก → Neural Networks, Random Forest

2. จำนวน features

น้อย → ทุกอัลกอริทึมทำได้ดี
มาก → Naive Bayes, Linear models
มากมาก → Dimensionality reduction ก่อน

3. ความต้องการ interpretability

สูง → Decision Tree, Linear models
ปานกลาง → k-NN, Naive Bayes
ต่ำ → Neural Networks, Ensemble methods

4. ความเร็วในการ train/predict

ต้องการเร็ว → Naive Bayes, Linear models
ปานกลาง → Decision Tree, k-NN (ถ้าข้อมูลไม่มาก)
ช้าได้ → Neural Networks, SVM

5. ลักษณะข้อมูล

Linear separable → Linear models
Non-linear → k-NN, Decision Tree, Neural Networks
Text → Naive Bayes, Linear SVM
Images → CNN (deep learning)

🏁 แนวทางการเริ่มต้น

เริ่มด้วยโมเดลง่ายๆ เป็น baseline
ลอง 2-3 algorithms ที่ต่างกัน
ใช้ cross-validation เปรียบเทียบ
ปรับ hyperparameters ของตัวที่ดีที่สุด
พิจารณา ensemble ถ้าต้องการประสิทธิภาพสูงสุด

📊 ตารางเปรียบเทียบ Algorithms

Algorithm	ความเร็ว Train	ความเร็ว Predict	Interpretability	เหมาะกับข้อมูล
k-NN	⚡ เร็วมาก (ไม่ต้อง train)	🐌 ช้า	⭐⭐⭐ ดี	Non-linear, ข้อมูลน้อย-ปานกลาง
Decision Tree	⚡⚡ เร็ว	⚡⚡⚡ เร็วมาก	⭐⭐⭐⭐⭐ ดีมาก	ทั้ง linear/non-linear, categorical
Naive Bayes	⚡⚡⚡ เร็วมาก	⚡⚡⚡ เร็วมาก	⭐⭐⭐ ดี	Text, มิติสูง, ข้อมูลน้อย

💡 5. Best Practices และข้อควรระวัง

✅ สิ่งที่ควรทำ

1. เข้าใจข้อมูลก่อน

EDA (Exploratory Data Analysis)
ดู distributions, correlations
หา outliers, missing values

2. Preprocessing ให้ดี

Handle missing values
Scale features สำหรับ k-NN
Encode categorical variables

3. ป้องกัน data leakage

Scale หลังแบ่งข้อมูล
ไม่ใช้ test set ในการตัดสินใจใดๆ

4. Document ทุกอย่าง

เหตุผลในการเลือก algorithm
Hyperparameters ที่ใช้
ผลการทดลอง

❌ สิ่งที่ไม่ควรทำ

1. อย่าเชื่อ accuracy อย่างเดียว

ดู metrics อื่นด้วย
พิจารณา business impact

2. อย่า overfit กับ validation set

ลองหลายๆ hyperparameters จนเกินไป
ควรมี test set แยกไว้

3. อย่าใช้ default parameters เสมอ

ทุก dataset ต่างกัน
ต้อง tune ให้เหมาะสม

4. อย่าลืม sanity check

Random baseline
Simple rule-based baseline
ถ้า ML ไม่ดีกว่ามาก อาจไม่คุ้ม

🎓 สรุป

การเรียนรู้ Machine Learning เปรียบเสมือนการเรียนรู้ภาษาใหม่ - ต้องเริ่มจากพื้นฐาน ฝึกฝนบ่อยๆ และค่อยๆ เพิ่มความซับซ้อน

Key Takeaways

ML คือการเรียนรู้จากข้อมูล ไม่ใช่การเขียนกฎตายตัว
ไม่มี algorithm ที่ดีที่สุดเสมอ - ขึ้นอยู่กับปัญหาและข้อมูล
การวัดผลต้องรอบด้าน - อย่าดู accuracy อย่างเดียว
Overfitting คือศัตรู - ระวังไม่ให้จำแทนที่จะเข้าใจ
Practice makes perfect - ยิ่งลองมากยิ่งเก่ง

จำไว้ว่า Machine Learning ไม่ใช่เวทมนตร์ แต่เป็นเครื่องมือที่ทรงพลัง เมื่อใช้อย่างเข้าใจและเหมาะสม! 🚀

🤖 Week 3: Introduction to Machine Learning & Classification

🎯 บทนำ: ทำไมเครื่องต้องเรียนรู้?

📚 1. Machine Learning Fundamentals

1.1 นิยามของ Machine Learning

🤔 ทำไมต้องใช้ Machine Learning?

1. ปัญหาที่ซับซ้อนเกินกว่าจะเขียนกฎ

2. ปัญหาที่เปลี่ยนแปลงตลอดเวลา

3. ปัญหาที่มนุษย์ทำได้แต่อธิบายไม่ได้

1.2 ประเภทของการเรียนรู้

🏷️ 1. Supervised Learning (การเรียนรู้แบบมีผู้สอน)

ตัวอย่าง

🔍 2. Unsupervised Learning (การเรียนรู้แบบไม่มีผู้สอน)

ตัวอย่าง

🎮 3. Reinforcement Learning (การเรียนรู้แบบเสริมกำลัง)

ตัวอย่าง

1.3 การแบ่งข้อมูลสำหรับ Machine Learning

🎯 ทำไมต้องแบ่งข้อมูล?

📊 การแบ่งข้อมูล 3 ส่วน

1. Training Set (ชุดฝึก)

2. Validation Set (ชุดตรวจสอบ)

3. Test Set (ชุดทดสอบ)

💡 Best Practices

1.4 Overfitting และ Underfitting

🎭 Overfitting (เรียนรู้มากเกินไป)

🤷 Underfitting (เรียนรู้น้อยเกินไป)

⚖️ การหาจุดสมดุล

🎯 2. Classification Algorithms พื้นฐาน

2.1 k-Nearest Neighbors (k-NN)

🏘️ หลักการทำงาน

📐 การวัดระยะทาง

🎯 การวัดระยะทาง 2 แบบ

1. Euclidean Distance

2. Manhattan Distance

3. Cosine Similarity

🎛️ การเลือกค่า k

หลักการเลือก k

💻 ตัวอย่าง Code

⚡ ข้อดีและข้อเสีย

✅ ข้อดี

❌ ข้อเสีย

2.2 Decision Trees (ต้นไม้ตัดสินใจ)

🌳 หลักการทำงาน

ตัวอย่าง: แยกผลไม้

📊 การสร้างต้นไม้

🎯 Metrics สำหรับเลือก Feature

1. Information Gain (based on Entropy)

2. Gini Impurity

🌿 การ Pruning (ตัดแต่งต้นไม้)

Pre-pruning (ป้องกันไว้ก่อน)

Post-pruning (ตัดทีหลัง)

💻 ตัวอย่าง Code:

⚡ ข้อดีและข้อเสีย

✅ ข้อดี:

❌ ข้อเสีย:

2.3 Naive Bayes

🎲 หลักการทำงาน

Bayes' Theorem

แปลเป็นภาษาคน

🤝 สมมติฐาน "Naive"

📈 ประเภทของ Naive Bayes

1. Gaussian Naive Bayes

2. Multinomial Naive Bayes

3. Bernoulli Naive Bayes

💻 ตัวอย่าง Code:

⚡ ข้อดีและข้อเสีย

✅ ข้อดี:

❌ ข้อเสีย:

📊 3. Model Evaluation

3.1 Confusion Matrix

🎯 อะไรคือ Confusion Matrix?

สำหรับ Binary Classification

ตัวอย่าง: ตรวจโรค

3.2 Metrics การวัดประสิทธิภาพ

📏 1. Accuracy (ความแม่นยำโดยรวม)

🎯 2. Precision (ความแม่นยำเมื่อทายว่าใช่)

🔍 3. Recall/Sensitivity (ความสามารถหาของจริง)

⚖️ 4. F1-Score (ค่าเฉลี่ยแบบถ่วงน้ำหนัก)

📊 5. สำหรับ Multi-class Classification

3.3 Cross-validation

🔄 ทำไมต้องใช้ Cross-validation?