เข้าใจเมทริกซ์การประเมินโมเดล Machine Learning

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

https://glassboxmedicine.com/2019/02/23/measuring-performance-auc-auroc/

1. Confusion Matrix

Confusion Matrix เป็นตารางที่แสดงผลการทำนายเทียบกับค่าจริง ช่วยในการวิเคราะห์ประสิทธิภาพของโมเดลในแต่ละคลาส

https://www.datacamp.com/tutorial/what-is-a-confusion-matrix-in-machine-learning

• TP (True Positive): ทำนายถูกว่าเป็นบวก
• TN (True Negative): ทำนายถูกว่าเป็นลบ
• FP (False Positive): ทำนายผิดว่าเป็นบวก (Type I error)
• FN (False Negative): ทำนายผิดว่าเป็นลบ (Type II error)

def confusion_matrix(y_true, y_pred):
    tp = sum((t == 1 and p == 1) for t, p in zip(y_true, y_pred))
    tn = sum((t == 0 and p == 0) for t, p in zip(y_true, y_pred))
    fp = sum((t == 0 and p == 1) for t, p in zip(y_true, y_pred))
    fn = sum((t == 1 and p == 0) for t, p in zip(y_true, y_pred))
    return tp, tn, fp, fn

2. Accuracy (ความถูกต้อง)

Accuracy คือสัดส่วนของการทำนายที่ถูกต้องทั้งหมดเทียบกับจำนวนตัวอย่างทั้งหมด

สูตร: Accuracy = (TP + TN) / (TP + TN + FP + FN)

ข้อควรระวัง: Accuracy อาจให้ผลที่เข้าใจผิดในกรณีที่ข้อมูลไม่สมดุล (Imbalanced dataset)

def accuracy(tp, tn, fp, fn):
    return (tp + tn) / (tp + tn + fp + fn)

3. Precision (ความแม่นยำ)

Precision คือสัดส่วนของผลการทำนายที่ถูกต้องเมื่อเทียบกับผลการทำนายทั้งหมดที่โมเดลทำนายว่าเป็นคลาสบวก

สูตร: Precision = TP / (TP + FP)

เหมาะสำหรับ: กรณีที่ต้องการลด False Positive เช่น การกรองสแปม

def precision(tp, fp):
    return tp / (tp + fp) if (tp + fp) > 0 else 0

4. Recall (ความครบถ้วน)

Recall คือสัดส่วนของตัวอย่างที่เป็นคลาสบวกจริง ๆ ที่โมเดลสามารถทำนายได้ถูกต้อง

สูตร: Recall = TP / (TP + FN)

เหมาะสำหรับ: กรณีที่ต้องการลด False Negative เช่น การตรวจจับโรคร้ายแรง

def recall(tp, fn):
    return tp / (tp + fn) if (tp + fn) > 0 else 0

5. F1-score

F1-score เป็นค่าเฉลี่ยฮาร์โมนิกของ Precision และ Recall ให้ค่าที่สมดุลระหว่างสองเมทริกซ์นี้

สูตร: F1 = 2 * (Precision * Recall) / (Precision + Recall)

เหมาะสำหรับ: กรณีที่ต้องการสมดุลระหว่าง Precision และ Recall

def f1_score(prec, rec):
    return 2 * (prec * rec) / (prec + rec) if (prec + rec) > 0 else 0

6. Specificity (ความจำเพาะ)

Specificity คือความสามารถในการระบุผลลัพธ์เชิงลบได้อย่างถูกต้อง

สูตร: Specificity = TN / (TN + FP)

เหมาะสำหรับ: การประเมินความสามารถของโมเดลในการระบุกรณีปกติ

def specificity(tn, fp):
    return tn / (tn + fp) if (tn + fp) > 0 else 0

7. ROC Curve และ AUC

ROC (Receiver Operating Characteristic) Curve แสดงความสัมพันธ์ระหว่าง True Positive Rate (Sensitivity หรือ Recall) และ False Positive Rate ที่ค่า threshold ต่างๆ

True Positive Rate = TP / (TP + FN) False Positive Rate = FP / (FP + TN)

AUC (Area Under the Curve) คือพื้นที่ใต้กราฟ ROC ยิ่งค่าเข้าใกล้ 1 แสดงว่าโมเดลมีประสิทธิภาพดี

เหมาะสำหรับ: การเปรียบเทียบประสิทธิภาพของโมเดลหลายๆ โมเดล

def roc_auc(y_true, y_scores):
    pos = [i for i, v in enumerate(y_true) if v == 1]
    neg = [i for i, v in enumerate(y_true) if v == 0]
    auc = 0
    for i in pos:
        for j in neg:
            if y_scores[i] > y_scores[j]:
                auc += 1
            elif y_scores[i] == y_scores[j]:
                auc += 0.5
    return auc / (len(pos) * len(neg))

8. Log Loss (Logarithmic Loss)

Log Loss วัดประสิทธิภาพของโมเดลการจำแนกประเภทที่ผลลัพธ์เป็นความน่าจะเป็น ค่ายิ่งต่ำยิ่งดี

สูตร: Log Loss = -1/N * Σ(y_i * log(p_i) + (1 — y_i) * log(1 — p_i))

เมื่อ N คือจำนวนตัวอย่าง, y_i คือค่าจริง (0 หรือ 1), p_i คือความน่าจะเป็นที่ทำนาย

เหมาะสำหรับ: การประเมินโมเดลที่ต้องการความแม่นยำของความน่าจะเป็น

def log_loss(y_true, y_pred):
    return -sum(y * math.log(p) + (1 - y) * math.log(1 - p) 
                for y, p in zip(y_true, y_pred)) / len(y_true)

9. Mean Absolute Error (MAE)

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

สูตร: MAE = (1/n) * Σ|y_true — y_pred|

เหมาะสำหรับ: การประเมินโมเดลการทำนายเชิงตัวเลขที่ต้องการความทนทานต่อค่าผิดปกติ (outliers)

def mean_absolute_error(y_true, y_pred):
    return sum(abs(t - p) for t, p in zip(y_true, y_pred)) / len(y_true)

10. Root Mean Square Error (RMSE)

RMSE เป็นอีกหนึ่งเมทริกซ์ที่ใช้วัดความแม่นยำของโมเดลการทำนายเชิงตัวเลข โดยคำนวณจากรากที่สองของค่าเฉลี่ยของความคลาดเคลื่อนยกกำลังสอง

สูตร: RMSE = √[(1/n) * Σ(y_true — y_pred)²]

เหมาะสำหรับ: การประเมินโมเดลการทำนายเชิงตัวเลขที่ต้องการให้ความสำคัญกับค่าผิดปกติมากขึ้น

def mean_squared_error(y_true, y_pred):
    return sum((t - p) ** 2 for t, p in zip(y_true, y_pred)) / len(y_true)

11. R-squared (R²)

R-squared หรือ Coefficient of Determination วัดสัดส่วนของความแปรปรวนในตัวแปรตามที่สามารถอธิบายได้ด้วยโมเดล

สูตร: R² = 1 — (Sum of Squared Residuals / Total Sum of Squares)

เหมาะสำหรับ: การประเมินความเหมาะสมของโมเดลการถดถอยเชิงเส้น

def r_squared(y_true, y_pred):
    y_mean = sum(y_true) / len(y_true)
    ss_tot = sum((y - y_mean) ** 2 for y in y_true)
    ss_res = sum((y - p) ** 2 for y, p in zip(y_true, y_pred))
    return 1 - (ss_res / ss_tot)

การเลือกใช้เมทริกซ์

การเลือกใช้เมทริกซ์ใดขึ้นอยู่กับประเภทของปัญหาและเป้าหมายของโมเดล:

• สำหรับปัญหาการจำแนกประเภท (Classification): ใช้ Precision, Recall, F1-score, Accuracy, ROC-AUC
• สำหรับปัญหาการทำนายเชิงตัวเลข (Regression): ใช้ MAE, RMSE, R-squared
• สำหรับโมเดลที่ต้องการความสมดุลระหว่างการระบุผลบวกและผลลบ: ใช้ F1-score
• สำหรับโมเดลที่ต้องการเน้นการระบุผลบวกได้ถูกต้อง: ให้ความสำคัญกับ Precision
• สำหรับโมเดลที่ต้องการเน้นการค้นหาผลบวกให้ได้มากที่สุด: ให้ความสำคัญกับ Recall