AI System Interpretability: การใช้ SHAP Values ในการอธิบายการตัดสินใจของโมเดล

ในยุคที่ AI กลายเป็นหัวใจสำคัญของการตัดสินใจทางธุรกิจ ความสามารถในการอธิบายว่าโมเดล Machine Learning ตัดสินใจอย่างไรนั้นมีความสำคัญมากขึ้นเรื่อยๆ ไม่ว่าจะเป็นเพื่อความโปร่งใสในการควบคุมกำกับดูแล หรือเพื่อสร้างความไว้วางใจกับผู้ใช้งาน บทความนี้จะพาคุณไปทำความรู้จักกับ SHAP (SHapley Additive exPlanations) ซึ่งเป็นเทคนิคที่ได้รับความนิยมมากที่สุดในการอธิบายการทำงานของโมเดล AI

กรณีศึกษา: บริษัทสตาร์ทอัพ AI ในกรุงเทพฯ

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

จุดเจ็บปวดเดิม

ทีมเดิมใช้โมเดล Deep Learning ที่มีความแม่นยำสูง แต่กลับเป็น "กล่องดำ" (Black Box) ที่ไม่สามารถอธิบายได้ว่าปัจจัยใดมีผลต่อการตัดสินใจมากที่สุด ทำให้เกิดปัญหาหลายประการ ได้แก่ ความเสี่ยงด้านการกำกับดูแล (Regulatory Risk) เพราะธนาคารกลางกำหนดให้ต้องสามารถอธิบายการตัดสินใจได้ ความไม่ไว้วางใจจากลูกค้าที่ถูกปฏิเสธโดยไม่ทราบเหตุผล และความยากลำบากในการ Debug เมื่อโมเดลให้ผลลัพธ์ที่ผิดพลาด

การแก้ปัญหาด้วย SHAP Values

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

SHAP Values คืออะไร?

SHAP (SHapley Additive exPlanations) พัฒนาจากทฤษฎี Game Theory โดย Scott Lundberg และ Su-In Lee จากมหาวิทยาลัย Washington หลักการคือการคำนวณว่าแต่ละ Feature (ตัวแปร) มีส่วนร่วมในการตัดสินใจของโมเดลมากน้อยเพียงใด โดยพิจารณาจากค่า Shapley Value ในทฤษฎีเกม

ค่า SHAP มีคุณสมบัติสำคัญ 3 ประการ ได้แก่ Local Explanatory ซึ่งสามารถอธิบายการตัดสินใจเฉพาะรายบุคคลได้ Consistency หมายความว่าถ้าโมเดลเปลี่ยนแปลงเพื่อให้ Feature มีผลมากขึ้น ค่า SHAP ก็จะเพิ่มขึ้นด้วย และ Additivity คือผลรวมของค่า SHAP จากทุก Feature จะเท่ากับผลต่างระหว่าง Prediction กับ Baseline

การคำนวณ SHAP Values ด้วย HolySheep AI

HolySheep AI นำเสนอ API ที่รองรับการคำนวณ SHAP Values อย่างมีประสิทธิภาพ พร้อมความสามารถในการ Integrate กับโมเดล AI หลากหลายประเภท ราคาเริ่มต้นเพียง $0.42 ต่อ Million Tokens สำหรับ DeepSeek V3.2 ทำให้เป็นทางเลือกที่คุ้มค่าสำหรับองค์กรทุกขนาด คุณสามารถ สมัครที่นี่ เพื่อรับเครดิตฟรีเมื่อลงทะเบียน

ตัวอย่างการใช้งาน Python Library

import shap
import numpy as np
from openai import OpenAI

เชื่อมต่อกับ HolySheep AI API
client = OpenAI(
    api_key="YOUR_HOLYSHEEP_API_KEY",
    base_url="https://api.holysheep.ai/v1"
)

def explain_prediction_with_shap(model, input_data, feature_names):
    """
    ฟังก์ชันสำหรับอธิบายการตัดสินใจของโมเดลด้วย SHAP Values
    """
    # สร้าง SHAP Explainer
    explainer = shap.TreeExplainer(model)
    
    # คำนวณ SHAP Values
    shap_values = explainer.shap_values(input_data)
    
    # สร้างคำอธิบายในรูปแบบข้อความ
    prompt = f"""
    Based on the following SHAP values, generate a human-readable explanation:
    
    Feature Values: {dict(zip(feature_names, input_data[0]))}
    SHAP Values: {dict(zip(feature_names, shap_values[0]))}
    Prediction: {model.predict(input_data)[0]}
    
    Please explain which factors contributed positively and negatively.
    """
    
    response = client.chat.completions.create(
        model="deepseek-chat",
        messages=[
            {"role": "system", "content": "You are an AI model interpretability expert."},
            {"role": "user", "content": prompt}
        ],
        temperature=0.3,
        max_tokens=500
    )
    
    return {
        "shap_values": dict(zip(feature_names, shap_values[0])),
        "explanation": response.choices[0].message.content
    }

ตัวอย่างการใช้งานกับโมเดล Credit Scoring
feature_names = [
    "income", "debt_ratio", "credit_history_length", 
    "payment punctuality", "employment_status", "age"
]

sample_input = np.array([[
    45000, 0.35, 60, 0.92, 1, 32
]])

result = explain_prediction_with_shap(credit_model, sample_input, feature_names)
print(result["explanation"])

การสร้าง SHAP Summary Plot

import matplotlib.pyplot as plt
import pandas as pd

def create_shap_summary_plot(shap_values, feature_names, output_path):
    """
    สร้าง SHAP Summary Plot เพื่อแสดงภาพรวมความสำคัญของ Features
    """
    plt.figure(figsize=(12, 8))
    
    # สร้าง DataFrame สำหรับ SHAP Values
    shap_df = pd.DataFrame(shap_values, columns=feature_names)
    
    # Plot SHAP Summary
    shap.summary_plot(
        shap_values, 
        feature_names=feature_names,
        show=False,
        plot_size=(12, 8)
    )
    
    plt.title("SHAP Summary Plot - Feature Importance", fontsize=14, pad=20)
    plt.xlabel("SHAP Value (Impact on Model Output)", fontsize=12)
    plt.tight_layout()
    plt.savefig(output_path, dpi=300, bbox_inches='tight')
    plt.close()
    
    return output_path

def generate_feature_contribution_report(shap_values, feature_names, sample_data):
    """
    สร้างรายงานสรุปการมีส่วนร่วมของแต่ละ Feature
    """
    report = []
    report.append("=" * 60)
    report.append("FEATURE CONTRIBUTION ANALYSIS REPORT")
    report.append("=" * 60)
    
    # คำนวณค่าเฉลี่ย SHAP Values
    mean_shap = np.abs(shap_values).mean(axis=0)
    
    # จัดเรียงตามความสำคัญ
    importance_order = np.argsort(mean_shap)[::-1]
    
    report.append(f"\n{'Feature':<25} {'Mean |SHAP|':<15} {'Contribution %':<15}")
    report.append("-" * 55)
    
    for idx in importance_order:
        contribution = (mean_shap[idx] / mean_shap.sum()) * 100
        report.append(
            f"{feature_names[idx]:<25} {mean_shap[idx]:<15.4f} {contribution:<15.2f}%"
        )
    
    report.append("=" * 60)
    return "\n".join(report)

ตัวอย่างการใช้งาน
summary_path = create_shap_summary_plot(
    test_shap_values, 
    feature_names,
    "shap_summary_plot.png"
)

report = generate_feature_contribution_report(
    test_shap_values,
    feature_names,
    test_data
)

print(report)
print(f"\nPlot saved to: {summary_path}")

การ Integration กับ Production System

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import List, Dict, Optional
import joblib
import numpy as np

app = FastAPI(title="SHAP-powered Prediction API")

โหลดโมเดลและ SHAP Explainer
model = joblib.load("credit_model.pkl")
explainer = joblib.load("shap_explainer.pkl")

class PredictionRequest(BaseModel):
    income: float
    debt_ratio: float
    credit_history_months: int
    payment_punctuality: float
    employment_status: int  # 0= unemployed, 1= employed, 2= self-employed
    age: int
    generate_explanation: bool = True

class PredictionResponse(BaseModel):
    prediction: str
    probability: float
    explanation: Optional[Dict] = None

@app.post("/predict", response_model=PredictionResponse)
async def predict_with_explanation(request: PredictionRequest):
    """
    API endpoint สำหรับทำนายพร้อมอธิบายด้วย SHAP
    """
    # แปลงข้อมูลเป็น numpy array
    input_data = np.array([[
        request.income,
        request.debt_ratio,
        request.credit_history_months,
        request.payment_punctuality,
        request.employment_status,
        request.age
    ]])
    
    feature_names = [
        "income", "debt_ratio", "credit_history_months",
        "payment_punctuality", "employment_status", "age"
    ]
    
    # ทำนาย
    prediction = model.predict(input_data)[0]
    probability = model.predict_proba(input_data)[0][1]
    
    response = PredictionResponse(
        prediction="Approved" if prediction == 1 else "Rejected",
        probability=float(probability)
    )
    
    # คำนวณ SHAP Values หากต้องการอธิบาย
    if request.generate_explanation:
        shap_values = explainer.shap_values(input_data)[0]
        
        # สร้างคำอธิบาย
        positive_factors = []
        negative_factors = []
        
        for name, value, shap in zip(feature_names, input_data[0], shap_values):
            if shap > 0:
                positive_factors.append({
                    "feature": name,
                    "value": float(value),
                    "contribution": float(shap)
                })
            else:
                negative_factors.append({
                    "feature": name,
                    "value": float(value),
                    "contribution": float(shap)
                })
        
        # เรียงลำดับตามค่าความสำคัญ
        positive_factors.sort(key=lambda x: x["contribution"], reverse=True)
        negative_factors.sort(key=lambda x: x["contribution"])
        
        response.explanation = {
            "positive_factors": positive_factors[:3],  # Top 3 positive
            "negative_factors": negative_factors[:3],  # Top 3 negative
            "summary": f"Main approval reason: {positive_factors[0]['feature']}" 
                      if prediction == 1 else 
                      f"Main rejection reason: {negative_factors[0]['feature']}"
        }
    
    return response

@app.get("/model-info")
async def get_model_info():
    """
    ดึงข้อมูลเกี่ยวกับโมเดลและ SHAP Explainer
    """
    return {
        "model_type": "XGBoost Classifier",
        "model_version": "2.1.0",
        "features": feature_names,
        "shap_explainer_type": "TreeExplainer",
        "last_updated": "2025-01-15"
    }

ประโยชน์ทางธุรกิจของ SHAP

การนำ SHAP Values มาใช้ในองค์กรนั้นสร้างประโยชน์ได้หลายมิติ ทั้งในแง่ของการปฏิบัติตามกฎระเบียบ เพราะหลายอุตสาหกรรม โดยเฉพาะการเงินและประกันภัย มีกฎหมายกำหนดให้ต้องสามารถอธิบายการตัดสินใ