XGBoost vs LightGBM 2026: Gradient Boosting และคำถามสัมภาษณ์ Data Science

# gradient_boosting_demo.py
import numpy as np
from sklearn.tree import DecisionTreeRegressor

def gradient_boosting_from_scratch(X, y, n_estimators=100, learning_rate=0.1, max_depth=3):
    """Simplified gradient boosting for regression to illustrate the algorithm."""
    # Initialize predictions with the mean (minimizes squared error)
    predictions = np.full(len(y), y.mean())
    trees = []
    
    for _ in range(n_estimators):
        # Compute negative gradient (residuals for MSE loss)
        residuals = y - predictions
        
        # Fit a tree to the residuals
        tree = DecisionTreeRegressor(max_depth=max_depth)
        tree.fit(X, residuals)
        trees.append(tree)
        
        # Update predictions with shrinkage (learning rate)
        predictions += learning_rate * tree.predict(X)
    
    return trees, y.mean()

# xgboost_classification.py
import xgboost as xgb
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

# Generate synthetic classification data
X, y = make_classification(n_samples=10000, n_features=20, n_informative=10, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# XGBoost with commonly tuned hyperparameters
model = xgb.XGBClassifier(
    n_estimators=500,           # Number of boosting rounds
    max_depth=6,                # Maximum tree depth (controls complexity)
    learning_rate=0.1,          # Shrinkage factor (eta in XGBoost docs)
    subsample=0.8,              # Row sampling ratio per tree
    colsample_bytree=0.8,       # Column sampling ratio per tree
    reg_alpha=0.1,              # L1 regularization on leaf weights
    reg_lambda=1.0,             # L2 regularization on leaf weights
    tree_method='hist',         # Histogram-based algorithm (faster)
    early_stopping_rounds=50,   # Stop if no improvement after 50 rounds
    random_state=42
)

model.fit(
    X_train, y_train,
    eval_set=[(X_test, y_test)],  # Validation set for early stopping
    verbose=False
)

print(f"Best iteration: {model.best_iteration}")
print(f"Test accuracy: {model.score(X_test, y_test):.4f}")

# lightgbm_with_categorical.py
import lightgbm as lgb
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split

# Create dataset with categorical features
np.random.seed(42)
df = pd.DataFrame({
    'category_a': np.random.choice(['low', 'medium', 'high'], 10000),
    'category_b': np.random.choice(['type1', 'type2', 'type3', 'type4'], 10000),
    'numeric_1': np.random.randn(10000),
    'numeric_2': np.random.randn(10000),
    'target': np.random.randint(0, 2, 10000)
})

# Convert to categorical dtype (LightGBM reads this automatically)
df['category_a'] = df['category_a'].astype('category')
df['category_b'] = df['category_b'].astype('category')

X = df.drop('target', axis=1)
y = df['target']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# LightGBM handles categorical features natively
model = lgb.LGBMClassifier(
    n_estimators=500,
    max_depth=-1,               # No limit (leaf-wise growth controls complexity)
    num_leaves=31,              # Maximum leaves per tree (key LightGBM param)
    learning_rate=0.1,
    subsample=0.8,
    colsample_bytree=0.8,
    min_child_samples=20,       # Minimum samples in a leaf
    reg_alpha=0.1,
    reg_lambda=1.0,
    random_state=42,
    verbose=-1
)

model.fit(
    X_train, y_train,
    eval_set=[(X_test, y_test)],
    callbacks=[lgb.early_stopping(50, verbose=False)]
)

print(f"Best iteration: {model.best_iteration_}")
print(f"Test accuracy: {model.score(X_test, y_test):.4f}")

# hyperparameter_tuning.py
import optuna
import xgboost as xgb
from sklearn.model_selection import cross_val_score
from sklearn.datasets import make_classification

X, y = make_classification(n_samples=5000, n_features=20, n_informative=10, random_state=42)

def objective(trial):
    """Optuna objective for XGBoost hyperparameter optimization."""
    params = {
        # Start with learning rate and n_estimators
        'learning_rate': trial.suggest_float('learning_rate', 0.01, 0.3, log=True),
        'n_estimators': trial.suggest_int('n_estimators', 100, 1000),
        
        # Tree complexity (most important for bias-variance tradeoff)
        'max_depth': trial.suggest_int('max_depth', 3, 10),
        'min_child_weight': trial.suggest_int('min_child_weight', 1, 10),
        
        # Regularization (reduce overfitting)
        'reg_alpha': trial.suggest_float('reg_alpha', 1e-8, 10.0, log=True),
        'reg_lambda': trial.suggest_float('reg_lambda', 1e-8, 10.0, log=True),
        
        # Sampling (stochastic gradient boosting)
        'subsample': trial.suggest_float('subsample', 0.5, 1.0),
        'colsample_bytree': trial.suggest_float('colsample_bytree', 0.5, 1.0),
        
        'tree_method': 'hist',
        'random_state': 42
    }
    
    model = xgb.XGBClassifier(**params)
    scores = cross_val_score(model, X, y, cv=5, scoring='roc_auc')
    return scores.mean()

study = optuna.create_study(direction='maximize')
study.optimize(objective, n_trials=50, show_progress_bar=True)

print(f"Best ROC-AUC: {study.best_value:.4f}")
print(f"Best params: {study.best_params}")

# feature_importance.py
import xgboost as xgb
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification

X, y = make_classification(n_samples=5000, n_features=20, n_informative=10, random_state=42)
feature_names = [f'feature_{i}' for i in range(20)]

model = xgb.XGBClassifier(n_estimators=100, random_state=42)
model.fit(X, y)

# Three importance types available
importance_types = ['weight', 'gain', 'cover']

for imp_type in importance_types:
    importance = model.get_booster().get_score(importance_type=imp_type)
    print(f"\n{imp_type.upper()} importance (top 5):")
    sorted_imp = sorted(importance.items(), key=lambda x: x[1], reverse=True)[:5]
    for feat, score in sorted_imp:
        print(f"  {feat}: {score:.2f}")

# model_serialization.py
import xgboost as xgb
import json

# Train a model
model = xgb.XGBClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# Save in XGBoost's native binary format (recommended for production)
model.save_model('model.ubj')  # Universal Binary JSON format

# Load for inference
loaded_model = xgb.XGBClassifier()
loaded_model.load_model('model.ubj')

# For model versioning, save with metadata
metadata = {
    'version': '1.0.0',
    'trained_at': '2026-09-17',
    'features': feature_names,
    'best_iteration': model.best_iteration
}
with open('model_metadata.json', 'w') as f:
    json.dump(metadata, f)