25 คำถามสัมภาษณ์ Data Science ยอดนิยมในปี 2026

คำถามสัมภาษณ์ Data Science ในปี 2026 ไม่ได้วัดแค่ความจำตำราเรียน ทีมสัมภาษณ์ของบริษัทชั้นนำจะทดสอบความสามารถในการใช้เหตุผลเชิงสถิติ การเลือก feature engineering ที่เหมาะสม การประเมินโมเดลที่ลึกกว่าค่า accuracy และการแปลงปัญหาทางธุรกิจให้เป็น pipeline เชิงวิเคราะห์ คู่มือนี้รวบรวม 25 คำถามที่ปรากฏซ้ำในการสัมภาษณ์นักวิทยาศาสตร์ข้อมูลจากบริษัทสตาร์ทอัพไปจนถึงบริษัทชั้นนำระดับโลก

ความน่าจะเป็นและพื้นฐานสถิติ

Q1: โยนเหรียญ 10 ครั้ง ออกหัว 8 ครั้ง เหรียญนั้นมีความลำเอียงหรือไม่?

คำตอบแบบรีบด่วนคือ "ใช่" แต่แนวทางที่เข้มงวดต้องใช้ binomial test ภายใต้สมมติฐานว่าง (เหรียญยุติธรรม p=0.5) ความน่าจะเป็นที่จะได้หัว 8 ครั้งขึ้นไปใน 10 ครั้งอยู่ที่ประมาณ 5.5% ซึ่งไม่ต่ำกว่าระดับนัยสำคัญมาตรฐาน 5% จึงไม่สามารถสรุปได้ว่าเหรียญมีความลำเอียงที่ alpha = 0.05

# binomial_test.py
from scipy import stats

# Two-sided binomial test: is the coin fair?
result = stats.binomtest(k=8, n=10, p=0.5, alternative='two-sided')
print(f"p-value: {result.pvalue:.4f}")  # 0.1094 (two-sided)
print(f"Reject H0 at alpha=0.05? {result.pvalue < 0.05}")  # False

คำถามนี้ทดสอบว่าผู้สมัครใช้สัญชาตญาณหรือการทดสอบสมมติฐานอย่างเป็นทางการ ผู้สัมภาษณ์มักต่อด้วยการถามเรื่อง Type I และ Type II errors และต้องการขนาดตัวอย่างเท่าใดเพื่อตรวจจับความลำเอียงที่ p=0.7 ด้วยกำลัง 80%

Q2: อธิบายความแตกต่างระหว่างแนวทาง Bayesian และ Frequentist ในการอนุมานทางสถิติ

การอนุมานแบบ Frequentist ถือว่าพารามิเตอร์มีค่าคงที่แต่ไม่ทราบค่า ช่วงความเชื่อมั่น 95% หมายความว่า หากทำการทดลองซ้ำหลายครั้ง 95% ของช่วงที่คำนวณได้จะครอบคลุมค่าพารามิเตอร์จริง การอนุมานแบบ Bayesian ถือว่าพารามิเตอร์เป็นตัวแปรสุ่มที่มีการแจกแจงเชิงก่อน และอัปเดตความเชื่อผ่านทฤษฎีของ Bayes เพื่อสร้างการแจกแจงเชิงหลัง ช่วงความน่าเชื่อถือ 95% หมายความว่า เมื่อพิจารณาข้อมูลที่สังเกตและการแจกแจงเชิงก่อน มีความน่าจะเป็น 95% ที่พารามิเตอร์อยู่ในช่วงนี้

# bayesian_vs_frequentist.py
import numpy as np
from scipy import stats

# Frequentist: confidence interval for a mean
data = np.array([23.1, 25.4, 22.8, 24.9, 23.7, 25.1, 24.3])
ci = stats.t.interval(0.95, df=len(data)-1, loc=np.mean(data), scale=stats.sem(data))
print(f"95% CI (frequentist): [{ci[0]:.2f}, {ci[1]:.2f}]")

# Bayesian: posterior with conjugate prior (Normal-Normal)
prior_mean, prior_var = 24.0, 4.0  # prior belief
data_mean, data_var = np.mean(data), np.var(data, ddof=1) / len(data)
# Posterior parameters (conjugate update)
post_var = 1 / (1/prior_var + 1/data_var)
post_mean = post_var * (prior_mean/prior_var + data_mean/data_var)
post_ci = stats.norm.interval(0.95, loc=post_mean, scale=np.sqrt(post_var))
print(f"95% credible interval (Bayesian): [{post_ci[0]:.2f}, {post_ci[1]:.2f}]")

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

Q3: ทฤษฎีบทขีดจำกัดกลางล้มเหลวเมื่อใด และมีความสำคัญต่อ Data Science อย่างไร?

ทฤษฎีบทขีดจำกัดกลาง (CLT) รับประกันว่าค่าเฉลี่ยตัวอย่างจะลู่เข้าสู่การแจกแจงแบบปกติเมื่อ n เพิ่มขึ้น แต่ใช้ได้เมื่อประชากรมีความแปรปรวนจำกัดเท่านั้น การแจกแจงหางหนัก เช่น Cauchy หรือ Pareto ที่ alpha น้อยกว่าหรือเท่ากับ 2 ละเมิดข้อสมมติฐานนี้ ในทางปฏิบัติ สิ่งนี้กระทบกับการสร้างแบบจำลองผลตอบแทนทางการเงิน การวิเคราะห์การรับส่งข้อมูลเครือข่าย และทุกโดเมนที่มี outlier รุนแรง ค่ามัธยฐานหรือค่าเฉลี่ยแบบตัดแต่งจะเป็นตัวประมาณที่แข็งแกร่งกว่าในกรณีเหล่านี้

Feature Engineering และการเตรียมข้อมูล

Q4: ข้อมูลที่หายไปส่งผลต่อการเทรนโมเดลอย่างไร และมีกลยุทธ์อะไรบ้างนอกจากการ impute แบบง่าย?

กลไกการขาดหายของข้อมูลกำหนดกลยุทธ์ที่เหมาะสม MCAR (Missing Completely At Random) อนุญาตให้ตัดแถวออกได้โดยไม่เกิด bias MAR (Missing At Random) ได้ประโยชน์จากการ multiple imputation หรือแนวทางเชิงโมเดล MNAR (Missing Not At Random) ต้องการการสร้างแบบจำลองกลไกการขาดหายเองโดยเฉพาะโดเมน

# missing_data_strategies.py
import pandas as pd
from sklearn.impute import KNNImputer, SimpleImputer
from sklearn.experimental import enable_iterative_imputer
from sklearn.impute import IterativeImputer

df = pd.DataFrame({
    'age': [25, 30, None, 45, None, 38],
    'income': [50000, None, 70000, 90000, 60000, None],
    'score': [85, 90, 78, None, 88, 92]
})

# Strategy 1: KNN imputation (preserves local structure)
knn_imp = KNNImputer(n_neighbors=2)
df_knn = pd.DataFrame(knn_imp.fit_transform(df), columns=df.columns)

# Strategy 2: Iterative imputation (MICE-like, models each feature)
iter_imp = IterativeImputer(max_iter=10, random_state=42)
df_iter = pd.DataFrame(iter_imp.fit_transform(df), columns=df.columns)

# Strategy 3: Add missingness indicator (preserves signal in the pattern)
df['income_missing'] = df['income'].isna().astype(int)
print(df_knn.round(1))

สิ่งที่ผู้สัมภาษณ์มองหาคือ รูปแบบการขาดหายของข้อมูลอาจมีข้อมูลสำคัญอยู่ในตัวเอง การเพิ่มคอลัมน์ตัวบ่งชี้แบบไบนารีสำหรับฟีเจอร์ที่ขาดหายมักช่วยปรับปรุงประสิทธิภาพของโมเดล โดยเฉพาะใน gradient-boosted trees

Q5: อธิบาย target encoding และเมื่อใดที่มันเหนือกว่า one-hot encoding

One-hot encoding สร้างคอลัมน์ไบนารีแบบกระจัดกระจายต่อหมวดหมู่ สำหรับฟีเจอร์ที่มี cardinality สูง เช่น รหัสไปรษณีย์ user ID หรือ SKU สินค้า สิ่งนี้ทำให้มิติข้อมูลพุ่งสูงขึ้น Target encoding แทนที่แต่ละหมวดหมู่ด้วยค่าเฉลี่ยของตัวแปรเป้าหมายสำหรับหมวดหมู่นั้น ทำให้ได้คอลัมน์ตัวเลขหนาแน่นเพียงคอลัมน์เดียว

# target_encoding.py
import pandas as pd
import numpy as np
from sklearn.model_selection import KFold

def target_encode_kfold(df, col, target, n_splits=5):
    """Target encoding with K-fold regularization to prevent leakage."""
    encoded = pd.Series(index=df.index, dtype=float)
    global_mean = df[target].mean()
    kf = KFold(n_splits=n_splits, shuffle=True, random_state=42)

    for train_idx, val_idx in kf.split(df):
        # Compute means only from training fold
        means = df.iloc[train_idx].groupby(col)[target].mean()
        encoded.iloc[val_idx] = df.iloc[val_idx][col].map(means)

    # Fill categories unseen in training fold with global mean
    encoded.fillna(global_mean, inplace=True)
    return encoded

df = pd.DataFrame({
    'city': ['Paris', 'Lyon', 'Paris', 'Marseille', 'Lyon', 'Paris',
             'Marseille', 'Lyon', 'Paris', 'Marseille'],
    'hired': [1, 0, 1, 0, 1, 1, 0, 0, 1, 1]
})
df['city_encoded'] = target_encode_kfold(df, 'city', 'hired')
print(df[['city', 'city_encoded', 'hired']])

แนวทาง K-fold ป้องกัน data leakage โดยคำนวณค่าเฉลี่ยเป้าหมายจากตัวอย่างนอกกลุ่มเท่านั้น หากไม่มีการ regularization นี้ target encoding จะ overfit อย่างรุนแรงบน dataset ขนาดเล็ก

แนวคิดหลักของ Machine Learning

Q6: Bias-variance tradeoff คืออะไร และปรากฏในโมเดลแบบต้นไม้อย่างไร?

Bias วัดความผิดพลาดเชิงระบบ คือระยะห่างระหว่างการทำนายกับค่าจริงโดยเฉลี่ย Variance วัดความไวต่อชุดข้อมูลฝึก คือปริมาณที่การทำนายเปลี่ยนแปลงข้ามตัวอย่างที่ต่างกัน Decision tree ลึกเดี่ยวมี bias ต่ำแต่ variance สูง เพราะท่องจำข้อมูลฝึก Random forest ลด variance ผ่าน bootstrap aggregation (bagging) ขณะที่รักษา bias ต่ำ Gradient-boosted trees ลด bias แบบวนซ้ำโดยการ fit residuals แต่เสี่ยงต่อการเพิ่ม variance หากไม่มีการ regularization ที่เหมาะสม เช่น learning rate, max depth และ subsampling

Q7: เหตุใด accuracy จึงล้มเหลวในฐานะ metric สำหรับ dataset ที่ไม่สมดุล และมีทางเลือกอะไรบ้าง?

บน dataset ที่มีตัวอย่างลบ 95% และบวก 5% โมเดลที่ทำนาย "ลบ" ทุกอินพุตจะได้ความแม่นยำ 95% ในขณะที่ไร้ประโยชน์โดยสิ้นเชิง Precision-recall curves, F1 score และพื้นที่ใต้เส้นโค้ง precision-recall (AUPRC) สะท้อนประสิทธิภาพบน class ส่วนน้อยได้ดีกว่า สำหรับงาน ranking, AUC-ROC ทำงานได้ดีเพราะประเมินความสามารถในการแยกแยะที่ threshold ต่างๆ

# imbalanced_metrics.py
from sklearn.metrics import (
    classification_report, precision_recall_curve,
    average_precision_score, roc_auc_score
)
import numpy as np

# Simulated predictions on imbalanced data
np.random.seed(42)
y_true = np.array([0]*950 + [1]*50)  # 95/5 imbalance
y_scores = np.random.beta(2, 5, 1000)  # predicted probabilities
y_scores[y_true == 1] += 0.3  # positive class scores slightly higher
y_scores = np.clip(y_scores, 0, 1)
y_pred = (y_scores > 0.5).astype(int)

print(classification_report(y_true, y_pred, digits=3))
print(f"ROC AUC: {roc_auc_score(y_true, y_scores):.3f}")
print(f"Average Precision (AUPRC): {average_precision_score(y_true, y_scores):.3f}")

คำถามต่อเนื่องที่พบบ่อยคือ "เลือก precision หรือ recall?" คำตอบขึ้นอยู่กับต้นทุนของ false positive เทียบกับ false negative การตรวจจับการฉ้อโกงให้ความสำคัญกับ recall ส่วนการกรอง spam ให้ความสำคัญกับ precision

Q8: อธิบาย L1 และ L2 regularization และเมื่อใดควรใช้แต่ละแบบ

L1 regularization (Lasso) เพิ่มผลรวมของค่าสัมบูรณ์ของน้ำหนักเข้าไปใน loss function ทำให้สัมประสิทธิ์บางตัวมีค่าเท่ากับศูนย์อย่างแน่นอน ส่งผลให้ได้โมเดลแบบกระจัดกระจายและทำหน้าที่เป็นการคัดเลือกฟีเจอร์ในตัว L2 regularization (Ridge) เพิ่มผลรวมของกำลังสองของน้ำหนัก ลดสัมประสิทธิ์ทุกตัวให้ใกล้ศูนย์โดยไม่ตัดตัวใดออก ใช้ L1 เมื่อฟีเจอร์จำนวนมากไม่เกี่ยวข้องและต้องการความกระจัดกระจาย ใช้ L2 เมื่อทุกฟีเจอร์มีส่วนร่วมและมี multicollinearity Elastic Net รวมทั้งสองแบบและมักเป็นตัวเลือกเริ่มต้นเมื่อไม่ทราบอัตราส่วนที่เหมาะสม

Q9: Gradient-boosted trees (XGBoost/LightGBM) จัดการ categorical features ต่างกันอย่างไร?

XGBoost ตามปกติต้องการ one-hot encoding หรือ ordinal encoding ก่อนฝึก LightGBM จัดการ categorical features โดยตรงผ่านอัลกอริทึมค้นหา split ที่เหมาะสมซึ่งจัดกลุ่มหมวดหมู่ตามสถิติ gradient ลดพื้นที่การค้นหาแบบเอ็กซ์โปเนนเชียลให้เหลือเวลาเชิงเส้น การจัดการโดยตรงนี้มักเหนือกว่า one-hot encoding โดยเฉพาะสำหรับฟีเจอร์ที่มี cardinality สูง และอธิบายว่าทำไม LightGBM มักฝึกได้เร็วกว่าบน tabular dataset

การประเมินและตรวจสอบโมเดล

Q10: Data leakage คืออะไร และแหล่งที่มาที่พบบ่อยที่สุดสามอย่างคืออะไร?

Data leakage เกิดขึ้นเมื่อข้อมูลจากนอก training distribution รั่วไหลเข้าสู่โมเดล ทำให้ validation metrics ดูดีขึ้นเกินจริงแต่ประสิทธิภาพในการผลิตลดลง แหล่งที่มาที่พบบ่อยที่สุดสามอย่างได้แก่:

1. Temporal leakage: ใช้ข้อมูลในอนาคตทำนายอดีต เช่น ใช้มูลค่าตลอดชีพของลูกค้าในการทำนายการเลิกใช้ในเดือนแรก
2. Target leakage: ฟีเจอร์ที่ได้มาจากตัวแปรเป้าหมาย เช่น "จำนวนการคืนเงิน" เพื่อทำนาย "จะขอคืนเงินหรือไม่"
3. Preprocessing leakage: การ fit scalers, encoders หรือ imputers บน dataset ทั้งหมดก่อนแบ่งข้อมูล

# leakage_prevention.py
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.impute import SimpleImputer
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import cross_val_score
import numpy as np

X = np.random.randn(1000, 10)
y = (X[:, 0] + X[:, 1] > 0).astype(int)

# WRONG: fit scaler on all data, then cross-validate
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)  # leakage: test fold info in scaling

# CORRECT: pipeline ensures preprocessing fits only on training folds
pipeline = Pipeline([
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler()),
    ('model', GradientBoostingClassifier(n_estimators=100, random_state=42))
])
scores = cross_val_score(pipeline, X, y, cv=5, scoring='roc_auc')
print(f"AUC (no leakage): {scores.mean():.3f} +/- {scores.std():.3f}")

Scikit-learn Pipelines เป็นมาตรการป้องกัน preprocessing leakage ขั้นมาตรฐาน ขั้นตอนการแปลงข้อมูลทุกขั้นตอนภายใน pipeline จะ refit บน training fold แต่ละอันโดยอิสระ

Q11: เมื่อใดควรใช้ time-series cross-validation แทน K-fold มาตรฐาน?

K-fold มาตรฐานสุ่มสับข้อมูล ซึ่งทำลายลำดับเวลา สำหรับ dataset ที่แถวมีองค์ประกอบเวลา เช่น ราคาหุ้น กิจกรรมผู้ใช้ ข้อมูลเซ็นเซอร์ สิ่งนี้สร้าง leakage จากอนาคตสู่อดีต Time-series cross-validation ใช้หน้าต่างแบบขยายหรือเลื่อน โดย training set ของแต่ละ fold มีเฉพาะข้อมูลก่อนหน้า validation set Scikit-learn มี TimeSeriesSplit สำหรับรูปแบบนี้

Deep Learning และ Neural Networks

Q12: เหตุใด deep networks จึงใช้ ReLU แทน sigmoid และ ReLU ล้มเหลวเมื่อใด?

Sigmoid บีบอัดเอาต์พุตเป็น (0, 1) แต่ gradient ของมันจะหายไปสำหรับอินพุตที่สุดขีด ใกล้ 0 หรือ 1 gradient จะเข้าสู่ศูนย์ ทำให้ backpropagation หยุดชะงักใน deep networks ReLU (max(0, x)) มี gradient คงที่ที่ 1 สำหรับอินพุตบวก ทำให้ฝึกได้เร็วขึ้น ReLU ล้มเหลวเมื่อ neurons ได้รับอินพุตลบอย่างสม่ำเสมอ (ปัญหา "dying ReLU") ทำให้ gradient เป็นศูนย์อย่างถาวร Leaky ReLU และ GELU (ใช้ใน Transformers) แก้ปัญหานี้โดยอนุญาต gradient ขนาดเล็กสำหรับค่าลบ

Q13: อธิบาย attention mechanism และเหตุใด Transformers จึงแทนที่ RNNs สำหรับงาน sequence

RNNs ประมวลผล sequence ทีละขั้น สร้างคอขวด ข้อมูลจาก token ต้นๆ ต้องอยู่รอดผ่าน hidden state ทุกขั้นตอนถัดมา Attention คำนวณความสัมพันธ์แบบคู่โดยตรงระหว่างทุกตำแหน่งพร้อมกัน ด้วย complexity O(n²) แต่ parallelization เต็มรูปแบบ Self-attention ใน Transformers สร้างเมทริกซ์ Query, Key และ Value จากอินพุต คำนวณ attention weights เป็น softmax(QK^T / sqrt(d_k)) * V

# self_attention.py
import torch
import torch.nn.functional as F

def self_attention(x, d_k):
    """Scaled dot-product self-attention from scratch."""
    # x shape: (batch_size, seq_len, d_model)
    batch_size, seq_len, d_model = x.shape

    # Linear projections for Q, K, V
    W_q = torch.randn(d_model, d_k) * 0.1
    W_k = torch.randn(d_model, d_k) * 0.1
    W_v = torch.randn(d_model, d_k) * 0.1

    Q = x @ W_q  # (batch, seq_len, d_k)
    K = x @ W_k
    V = x @ W_v

    # Scaled dot-product attention
    scores = Q @ K.transpose(-2, -1) / (d_k ** 0.5)  # (batch, seq_len, seq_len)
    weights = F.softmax(scores, dim=-1)  # attention weights
    output = weights @ V  # (batch, seq_len, d_k)

    return output, weights

# Example: 1 batch, 4 tokens, 8-dim embeddings
x = torch.randn(1, 4, 8)
out, attn = self_attention(x, d_k=8)
print(f"Output shape: {out.shape}")    # (1, 4, 8)
print(f"Attention weights:\n{attn[0].detach().numpy().round(3)}")

ข้อได้เปรียบหลักคือ attention ช่วยให้โมเดลเชื่อมโยงตำแหน่งสองตำแหน่งใดๆ โดยตรงโดยไม่คำนึงถึงระยะทาง แก้ปัญหา long-range dependency ที่ LSTM ประสบ

Q14: ความแตกต่างระหว่าง fine-tuning และ transfer learning คืออะไร และแต่ละแบบใช้เมื่อใด?

Transfer learning ใช้ representation ที่เรียนรู้จากโมเดล pretrained เป็นจุดเริ่มต้น Fine-tuning เป็นกลยุทธ์ transfer learning เฉพาะที่ปลดล็อกเลเยอร์ pretrained บางส่วนหรือทั้งหมดและฝึกต่อบน task เป้าหมาย Feature extraction (อีกกลยุทธ์หนึ่ง) แช่แข็งเลเยอร์ pretrained ทั้งหมดและฝึกเฉพาะ classification head ใหม่ Fine-tuning ทำงานได้ดีที่สุดกับข้อมูลเป้าหมายขนาดปานกลาง (หลักพันตัวอย่าง) Feature extraction เหมาะสำหรับ dataset ขนาดเล็กที่การ fine-tuning แบบเต็มจะ overfit

SQL และการจัดการข้อมูล

Q15: เขียน query เพื่อค้นหาเงินเดือนอันดับสองในแต่ละแผนกโดยไม่ใช้ window functions

-- second_highest_salary.sql
-- Approach: correlated subquery counting distinct higher salaries
SELECT d.department_name, e.employee_name, e.salary
FROM employees e
JOIN departments d ON e.department_id = d.id
WHERE (
    SELECT COUNT(DISTINCT e2.salary)
    FROM employees e2
    WHERE e2.department_id = e.department_id
      AND e2.salary > e.salary
) = 1
ORDER BY d.department_name;

ผู้สัมภาษณ์ใช้คำถามนี้เพื่อตรวจสอบพื้นฐาน SQL โดยไม่พึ่งความสะดวกของ RANK() หรือ DENSE_RANK() คำถามต่อเนื่องคือการแก้ด้วย window functions ซึ่งสะอาดกว่าแต่ทดสอบทักษะที่แตกต่างกัน

Q16: อธิบายความแตกต่างระหว่าง WHERE และ HAVING และแต่ละแบบถูกประมวลผลเมื่อใด?

WHERE กรองแถวก่อนการรวมกลุ่ม HAVING กรองกลุ่มหลังการรวมกลุ่ม ในลำดับการประมวลผล SQL, WHERE ถูกใช้ระหว่างการสแกนแถว, GROUP BY สร้างกลุ่ม, ฟังก์ชัน aggregate คำนวณ แล้ว HAVING กรองกลุ่มเหล่านั้น ข้อผิดพลาดที่พบบ่อยคือการใช้ HAVING โดยไม่มี GROUP BY หรือพยายามอ้างอิง alias ที่กำหนดใน SELECT จากภายใน WHERE

Data Science ประยุกต์และการออกแบบระบบ

Q17: ออกแบบ A/B test สำหรับอัลกอริทึมแนะนำใหม่อย่างไร?

การออกแบบต้องการห้าส่วนประกอบ ได้แก่ (1) metric หลักที่ชัดเจน เช่น click-through rate, conversion rate หรือรายได้ต่อผู้ใช้ (2) การวิเคราะห์ power เพื่อกำหนดขนาดตัวอย่าง (3) การสุ่มในระดับผู้ใช้ ไม่ใช่ระดับ session เพื่อหลีกเลี่ยงการปนเปื้อน (4) guardrail metrics ที่ต้องไม่ลดลง เช่น latency, อัตราการ crash และ (5) แผนการวิเคราะห์ที่ลงทะเบียนล่วงหน้าเพื่อป้องกัน p-hacking

Q18: โมเดลทำงานดีบน validation แต่แย่ใน production สาเหตุหลักสามอย่างคืออะไร?

1. Distribution shift: ข้อมูลฝึกไม่ตรงกับ traffic ใน production เช่น ข้อมูลประชากรผู้ใช้ต่างกัน ช่วงเวลาต่างกัน หรือพื้นที่ต่างกัน
2. Feature skew: ฟีเจอร์ที่คำนวณต่างกันในไปป์ไลน์ฝึก (batch) และ serving (real-time) เช่น การแยกวิเคราะห์ timestamp การจัดการค่าที่ขาดหาย หรือหน้าต่างการรวมกลุ่มที่ต่างกัน
3. Label leakage: ป้ายชื่อฝึกได้มาจากข้อมูลที่ไม่พร้อมใช้งานในเวลาทำนายใน production

การดีบักเริ่มจากการเปรียบเทียบการแจกแจงฟีเจอร์ระหว่างการฝึกและ production โดยใช้การทดสอบทางสถิติ เช่น KS test, PSI (Population Stability Index) บนแต่ละฟีเจอร์

Q19: อธิบาย CAP theorem และนัยสำคัญต่อ ML feature stores

CAP ระบุว่าระบบกระจายสามารถให้การรับประกันได้มากสุดสองจากสาม ได้แก่ Consistency (การอ่านทุกครั้งได้รับข้อมูลล่าสุด), Availability (ทุกคำขอได้รับการตอบสนอง) และ Partition tolerance (ระบบทำงานได้แม้เกิดความล้มเหลวเครือข่าย) Feature stores เผชิญกับการแลกเปลี่ยนนี้โดยตรง online stores (Redis, DynamoDB) ให้ความสำคัญกับ availability และ partition tolerance ยอมรับ eventual consistency ส่วน offline stores (BigQuery, Hive) ให้ความสำคัญกับ consistency สำหรับการฝึก batch สถาปัตยกรรม dual-store รองรับทั้งสองความต้องการ

Q20: จัดการ concept drift ในระบบ ML แบบ production อย่างไร?

Concept drift เกิดขึ้นเมื่อความสัมพันธ์ทางสถิติระหว่างฟีเจอร์และเป้าหมายเปลี่ยนแปลงตามเวลา วิธีการตรวจจับรวมถึงการตรวจสอบการเปลี่ยนแปลงการแจกแจงการทำนาย (PSI บนเอาต์พุตโมเดล) การติดตาม performance metrics บนข้อมูล production ที่มีป้ายชื่อ และการทดสอบทางสถิติบนการแจกแจงฟีเจอร์ขาเข้า กลยุทธ์การบรรเทา ได้แก่ การฝึกใหม่ตามกำหนดบน sliding window, online learning สำหรับ drift แบบค่อยเป็นค่อยไป หรือการเรียกใช้การฝึกใหม่เมื่อ drift metrics เกินขีดจำกัด

Python และ Pandas

Q21: ความแตกต่างระหว่าง apply(), map() และ transform() ใน Pandas คืออะไร?

map() ทำงานแบบ element-wise บน Series เท่านั้น apply() ทำงานทั้งบน Series และ DataFrames ส่งแต่ละแถว/คอลัมน์ไปยังฟังก์ชัน transform() ต้องการให้เอาต์พุตมีรูปร่างเดียวกับอินพุต ไม่สามารถ aggregate ได้ นัยสำคัญในทางปฏิบัติคือ transform() ช่วยให้การคำนวณระดับกลุ่มที่ broadcast กลับไปยัง index ต้นฉบับ ซึ่ง apply() ทำได้แต่มีประสิทธิภาพน้อยกว่า

# pandas_operations.py
import pandas as pd

df = pd.DataFrame({
    'team': ['A', 'A', 'B', 'B', 'A'],
    'score': [10, 20, 30, 40, 50]
})

# map: element-wise on Series
df['team_upper'] = df['team'].map({'A': 'Alpha', 'B': 'Beta'})

# apply: arbitrary function per row
df['score_label'] = df['score'].apply(lambda x: 'high' if x > 25 else 'low')

# transform: group-level, same shape output (broadcasts back)
df['team_mean'] = df.groupby('team')['score'].transform('mean')
df['score_normalized'] = df.groupby('team')['score'].transform(
    lambda x: (x - x.mean()) / x.std()
)
print(df)

Q22: อธิบาย GIL ของ Python และผลกระทบต่อ Data Science workflows

Global Interpreter Lock ป้องกันหลาย thread จากการรัน Python bytecode พร้อมกัน งาน CPU-bound เช่น การคำนวณตัวเลข การฝึกโมเดล ไม่ได้ประโยชน์จาก threading นี่คือเหตุผลที่ NumPy, pandas และ scikit-learn ใช้ C extensions ที่ปล่อย GIL และทำไม multiprocessing (ไม่ใช่ threading) จึงเป็นกลยุทธ์ parallelism มาตรฐานสำหรับโค้ด Python บริสุทธิ์ สำหรับงาน I/O-bound เช่น API calls, database queries threading ทำงานได้เพราะ GIL ถูกปล่อยระหว่างการรอ I/O

การลดมิติและ Unsupervised Learning

Q23: PCA vs. t-SNE vs. UMAP ใช้แต่ละแบบเมื่อใด?

PCA เป็นวิธีเชิงเส้นที่เพิ่มความแปรปรวนในมิติที่ project สูงสุด รักษาโครงสร้างภาพรวมและเป็น deterministic เหมาะสำหรับการประมวลผลเบื้องต้น (ลดจำนวนฟีเจอร์ก่อนสร้างโมเดล) และการแสดงภาพที่ตีความได้ t-SNE เป็นวิธีไม่เชิงเส้น ปรับแต่งสำหรับการแสดงภาพ 2D/3D โดยรักษา local neighborhoods ทำให้ระยะทางภาพรวมผิดเพี้ยนและไม่เหมาะสำหรับการประมวลผลเบื้องต้น UMAP รักษาทั้งโครงสร้างภายในและภาพรวมได้ดีกว่า t-SNE ทำงานเร็วกว่าบน dataset ขนาดใหญ่ และให้ผลลัพธ์ที่สม่ำเสมอกว่าระหว่างการรัน

| วิธีการ | เชิงเส้น | รักษาโครงสร้างภาพรวม | ความเร็ว (100K จุด) | กรณีใช้งาน | |--------|---------|---------------------|-------------------|-----------| | PCA | ใช่ | ใช่ | วินาที | การประมวลผลเบื้องต้น, ลดมิติ | | t-SNE | ไม่ | ไม่ | นาที | แสดงภาพคลัสเตอร์ (ข้อมูลขนาดเล็ก) | | UMAP | ไม่ | บางส่วน | วินาที | แสดงภาพ + การประมวลผลเบื้องต้น |

Q24: K-means ล้มเหลวอย่างไร และทางเลือกใดจัดการ cluster แบบไม่ทรงกลมได้?

K-means ถือว่า cluster ทรงกลมและมีขนาดเท่ากัน และใช้ระยะทาง Euclidean มันล้มเหลวบน cluster แบบยาว แหวน หรือมีความหนาแน่นต่างกัน DBSCAN ระบุ cluster ตามความหนาแน่น จัดการรูปร่างใดก็ได้และตรวจจับ outlier โดยอัตโนมัติ Gaussian Mixture Models (GMMs) สร้างแบบจำลองแต่ละ cluster เป็น multivariate Gaussian อนุญาตรูปร่างวงรี Spectral clustering ใช้ eigenvectors ของ graph Laplacian และจัดการเรขาคณิตที่ซับซ้อนแต่ scale ได้ไม่ดีเกิน ~10K จุด

การสื่อสารและผลกระทบทางธุรกิจ

Q25: ผู้มีส่วนได้ส่วนเสียถามว่า "ฟีเจอร์ไหนสำคัญที่สุดในโมเดล?" ตอบอย่างไร?

ความสำคัญของฟีเจอร์มีคำจำกัดความที่ถูกต้องหลายแบบ และคำตอบขึ้นอยู่กับผู้ฟัง สำหรับโมเดล tree-based มีมาตรวัดทั่วไปสามแบบ ได้แก่ split-based importance (ความบ่อยที่ฟีเจอร์ใช้ใน split), gain-based importance (การลดลงรวมใน loss จาก split บนฟีเจอร์นั้น) และ permutation importance (ประสิทธิภาพลดลงเท่าใดเมื่อสับเปลี่ยนฟีเจอร์แบบสุ่ม) SHAP values ให้คำตอบที่เข้มงวดที่สุด โดยวัดการมีส่วนร่วมของแต่ละฟีเจอร์ต่อการทำนายแต่ละรายการโดยใช้หลักการเชิงทฤษฎีเกม

# feature_importance_shap.py
import shap
import xgboost as xgb
from sklearn.datasets import make_classification

# Generate synthetic dataset
X, y = make_classification(n_samples=1000, n_features=10,
                           n_informative=5, random_state=42)

# Train XGBoost model
model = xgb.XGBClassifier(n_estimators=100, random_state=42, eval_metric='logloss')
model.fit(X, y)

# SHAP explanation
explainer = shap.TreeExplainer(model)
shap_values = explainer.shap_values(X)

# Global importance: mean absolute SHAP value per feature
import numpy as np
importance = np.abs(shap_values).mean(axis=0)
for i in np.argsort(importance)[::-1]:
    print(f"Feature {i}: {importance[i]:.4f}")

สำหรับผู้มีส่วนได้ส่วนเสีย ควรแปล SHAP values เป็นภาษาธุรกิจ เช่น "ลูกค้าที่มีรายได้เกิน 80,000 บาทมีแนวโน้มจะ convert มากกว่า 15% เมื่อปัจจัยอื่นเท่ากัน" แทนที่จะกล่าวว่า "Feature 3 มีค่า SHAP เฉลี่ย 0.23"

สรุป

• ความแม่นยำในการทดสอบสมมติฐานมีความสำคัญ รู้จักเมื่อใดควรใช้ binomial tests เข้าใจ p-values และแยกแยะเหตุผลแบบ Bayesian จาก Frequentist
• Feature engineering มักกำหนดประสิทธิภาพโมเดลมากกว่าการเลือกอัลกอริทึม ฝึกฝน target encoding, กลยุทธ์ข้อมูลที่หายไป และการป้องกัน leakage
• การประเมินเกินกว่า accuracy ใช้ AUPRC สำหรับข้อมูลไม่สมดุล, TimeSeriesSplit สำหรับข้อมูลเวลา และ pipelines เพื่อป้องกัน preprocessing leakage
• พื้นฐาน deep learning (attention, activation functions, transfer learning) ปรากฏแม้ในบทบาท data science ที่ใช้วิธีแบบ tabular เป็นหลัก
• คำถาม production ML (drift detection, A/B testing, feature stores) แยกแยะผู้สมัครอาวุโสจากจูเนียร์มากขึ้นเรื่อยๆ
• ทักษะการสื่อสารถูกทดสอบผ่านการอธิบายความสำคัญของฟีเจอร์ ฝึกการแปล SHAP values เป็นภาษาที่ผู้มีส่วนได้ส่วนเสียเข้าใจได้