LightGBM과 CatBoost 완벽 비교 가이드

그래디언트 부스팅의 양대 산맥인 LightGBM과 CatBoost를 비교 분석합니다. 각 알고리즘의 특징, 장단점, 그리고 어떤 상황에서 어떤 것을 선택해야 하는지 실무 관점에서 알아봅니다.

---

목차

1. 그래디언트_부스팅의_진화
2. LightGBM의_핵심_특징
3. CatBoost의_핵심_특징
4. 학습_속도_비교
5. 범주형_변수_처리_비교
6. 하이퍼파라미터_튜닝_전략
7. 과적합_방지_기법
8. 실전_모델_선택_가이드

---

1. 그래디언트 부스팅의 진화

김개발 씨는 데이터 분석팀에 배치된 지 한 달이 지났습니다. 오늘 팀장님이 고객 이탈 예측 모델을 만들어 보라는 미션을 주셨습니다.

"XGBoost 말고 요즘 뜨는 LightGBM이나 CatBoost 써봐요." 김개발 씨는 고개를 갸웃했습니다. 둘 다 부스팅이라는데, 대체 뭐가 다른 걸까요?

그래디언트 부스팅은 여러 개의 약한 학습기를 순차적으로 결합하여 강력한 예측 모델을 만드는 앙상블 기법입니다. 마치 시험에서 틀린 문제만 집중적으로 복습하는 것처럼, 이전 모델이 틀린 부분을 다음 모델이 보완합니다.

LightGBM과 CatBoost는 이 그래디언트 부스팅을 각자의 방식으로 최적화한 라이브러리입니다.

다음 코드를 살펴봅시다.

# 그래디언트 부스팅의 기본 원리
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

# 샘플 데이터 생성
X, y = make_classification(n_samples=1000, n_features=20, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# 기본 그래디언트 부스팅 모델
model = GradientBoostingClassifier(
    n_estimators=100,  # 100개의 약한 학습기를 순차적으로 학습
    learning_rate=0.1,  # 각 학습기의 기여도 조절
    max_depth=3  # 트리 깊이 제한
)
model.fit(X_train, y_train)
print(f"정확도: {model.score(X_test, y_test):.4f}")

김개발 씨는 입사 첫 달, 머신러닝 프로젝트에 투입되었습니다. 팀장님은 고객 이탈 예측이라는 중요한 업무를 맡겼고, 모델 선택의 갈림길에서 고민이 시작되었습니다.

"XGBoost는 이미 써봤으니까, 이번엔 다른 걸 써보세요." 선배 박시니어 씨가 조언했습니다. "요즘은 LightGBM이나 CatBoost를 많이 쓰거든요." 그렇다면 그래디언트 부스팅이란 정확히 무엇일까요?

쉽게 비유하자면, 그래디언트 부스팅은 마치 학원에서 오답 노트를 만드는 것과 같습니다. 첫 번째 시험을 보고, 틀린 문제를 집중적으로 공부합니다.

두 번째 시험에서도 또 틀린 문제가 나오면, 그것만 다시 집중 공부합니다. 이런 과정을 반복하면 결국 모든 유형의 문제를 맞출 수 있게 됩니다.

그래디언트 부스팅도 마찬가지입니다. 첫 번째 모델이 예측을 하고, 틀린 부분에 가중치를 부여합니다.

두 번째 모델은 그 틀린 부분을 집중적으로 학습합니다. 이 과정을 수백 번 반복하면 매우 정확한 예측 모델이 완성됩니다.

기존 그래디언트 부스팅의 문제는 무엇이었을까요? 바로 속도였습니다.

데이터가 커질수록 학습 시간이 기하급수적으로 늘어났습니다. 100만 건의 데이터를 학습하는 데 몇 시간이 걸리기도 했습니다.

실무에서는 빠른 실험과 반복이 중요한데, 이런 속도로는 업무 효율이 떨어질 수밖에 없었습니다. 이런 문제를 해결하기 위해 LightGBM과 CatBoost가 등장했습니다.

LightGBM은 마이크로소프트에서 개발했습니다. 이름에서 알 수 있듯이 가볍고 빠른 것이 특징입니다.

CatBoost는 러시아의 얀덱스에서 만들었습니다. 범주형 데이터를 기가 막히게 잘 처리하는 것이 강점입니다.

위의 코드를 살펴보면, 그래디언트 부스팅의 기본 구조를 이해할 수 있습니다. n_estimators는 몇 개의 약한 학습기를 만들 것인지를 정합니다.

learning_rate는 각 학습기가 얼마나 영향을 미칠지 조절합니다. max_depth는 각 트리의 깊이를 제한하여 과적합을 방지합니다.

실제 현업에서는 이 기본 그래디언트 부스팅보다 LightGBM이나 CatBoost를 훨씬 많이 사용합니다. 카카오, 네이버, 쿠팡 같은 대형 IT 기업들도 이 두 라이브러리를 적극 활용하고 있습니다.

김개발 씨는 고개를 끄덕였습니다. "그래서 둘 중에 뭘 써야 하는 건가요?" 박시니어 씨가 웃으며 대답했습니다.

"그건 상황에 따라 다르죠. 하나씩 자세히 알아봅시다."

실전 팁

💡 - 그래디언트 부스팅은 분류와 회귀 모두에 사용할 수 있습니다

• learning_rate를 낮추면 정확도는 올라가지만 학습 시간이 늘어납니다
• 과적합 방지를 위해 early_stopping을 활용하세요

---

2. LightGBM의 핵심 특징

김개발 씨는 먼저 LightGBM부터 공부하기로 했습니다. 공식 문서를 읽어보니 "Light Gradient Boosting Machine"의 약자라고 합니다.

마이크로소프트에서 2017년에 공개했는데, 빠르고 메모리 효율적이라는 설명이 눈에 띄었습니다.

LightGBM은 리프 중심 트리 분할 방식을 사용하여 학습 속도를 획기적으로 개선한 그래디언트 부스팅 프레임워크입니다. 마치 가장 효율적인 길만 골라서 가는 내비게이션처럼, 정보 이득이 가장 큰 리프 노드만 선택적으로 확장합니다.

대용량 데이터에서도 빠른 학습이 가능하여 캐글 대회에서 압도적인 인기를 얻고 있습니다.

다음 코드를 살펴봅시다.

import lightgbm as lgb
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
import numpy as np

# 대용량 데이터 시뮬레이션
X, y = make_classification(n_samples=50000, n_features=50, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# LightGBM 데이터셋 생성 (메모리 효율화)
train_data = lgb.Dataset(X_train, label=y_train)
test_data = lgb.Dataset(X_test, label=y_test, reference=train_data)

# LightGBM 파라미터 설정
params = {
    'objective': 'binary',  # 이진 분류
    'metric': 'auc',  # 평가 지표
    'boosting_type': 'gbdt',  # 기본 부스팅 방식
    'num_leaves': 31,  # 리프 노드 개수 (핵심 파라미터)
    'learning_rate': 0.05,
    'verbose': -1
}

# 학습 (early stopping 적용)
model = lgb.train(params, train_data, num_boost_round=1000,
                  valid_sets=[test_data], callbacks=[lgb.early_stopping(50)])

김개발 씨가 LightGBM 문서를 읽다가 고개를 갸웃했습니다. "리프 중심 트리 분할이 뭐예요?" 박시니어 씨가 화이트보드 앞으로 갔습니다.

"일반적인 의사결정 트리는 레벨 단위로 자라요. 마치 피라미드를 한 층씩 쌓아 올리는 것처럼요." 박시니어 씨가 그림을 그리며 설명했습니다.

기존 방식을 레벨 중심 분할이라고 합니다. 트리의 같은 깊이에 있는 모든 노드를 동시에 분할합니다.

균형 잡힌 트리가 만들어지지만, 불필요한 분할도 많이 일어납니다. 반면 LightGBM은 리프 중심 분할을 사용합니다.

마치 똑똑한 정원사가 가장 무성한 가지만 골라서 가지치기하는 것과 같습니다. 정보 이득이 가장 큰 리프 노드만 선택적으로 분할합니다.

이 방식의 장점은 명확합니다. 같은 수의 리프 노드를 사용해도 더 정확한 모델을 만들 수 있습니다.

불필요한 연산을 줄여서 학습 속도도 빨라집니다. 위의 코드에서 주목해야 할 부분이 있습니다.

바로 num_leaves 파라미터입니다. 이것이 LightGBM에서 가장 중요한 하이퍼파라미터입니다.

max_depth 대신 num_leaves로 모델의 복잡도를 조절합니다. lgb.Dataset을 사용하는 것도 눈여겨볼 만합니다.

LightGBM은 자체 데이터 포맷을 사용하여 메모리 사용량을 줄입니다. 대용량 데이터를 다룰 때 이 차이가 크게 느껴집니다.

실무에서 LightGBM이 빛을 발하는 순간은 언제일까요? 첫째, 데이터가 많을 때입니다.

100만 건 이상의 데이터에서 XGBoost보다 2배에서 10배까지 빠릅니다. 둘째, 피처가 많을 때입니다.

LightGBM은 히스토그램 기반 알고리즘으로 고차원 데이터도 효율적으로 처리합니다. 캐글 대회에서 LightGBM은 거의 필수 도구가 되었습니다.

빠른 실험이 가능하니까 다양한 피처 엔지니어링을 시도해볼 수 있기 때문입니다. 하지만 주의할 점도 있습니다.

리프 중심 분할은 과적합에 취약할 수 있습니다. num_leaves를 너무 크게 설정하면 학습 데이터에만 잘 맞는 모델이 됩니다.

일반적으로 num_leaves는 2의 max_depth 제곱보다 작게 설정하는 것이 좋습니다. 김개발 씨가 질문했습니다.

"그럼 CatBoost는 뭐가 다른 거예요?" 박시니어 씨가 다음 주제로 넘어갔습니다.

실전 팁

💡 - num_leaves는 2^max_depth보다 작게 설정하여 과적합을 방지하세요

• 대용량 데이터에서는 feature_fraction과 bagging_fraction으로 속도를 더 높일 수 있습니다
• GPU 학습을 지원하니 device='gpu' 옵션을 활용해보세요

---

3. CatBoost의 핵심 특징

이번에는 CatBoost 차례입니다. 김개발 씨는 CatBoost가 러시아 검색 엔진 얀덱스에서 만들었다는 것을 알게 되었습니다.

이름에 Cat이 들어가는데, 고양이랑 관련있는 걸까요? 아닙니다.

Categorical의 Cat입니다. 범주형 데이터를 잘 다룬다는 뜻이죠.

CatBoost는 범주형 변수를 자동으로 처리하고, 순서 기반 부스팅으로 과적합을 줄인 그래디언트 부스팅 프레임워크입니다. 마치 통역사가 외국어를 자동으로 번역해주는 것처럼, 문자열 범주형 데이터를 별도의 전처리 없이 바로 학습에 사용할 수 있습니다.

타겟 인코딩의 정보 누수 문제도 독특한 방식으로 해결했습니다.

다음 코드를 살펴봅시다.

from catboost import CatBoostClassifier, Pool
import pandas as pd
import numpy as np

# 범주형 데이터가 포함된 샘플 데이터
data = {
    'age': [25, 35, 45, 30, 50, 28, 42, 38],
    'city': ['서울', '부산', '서울', '대전', '부산', '서울', '대전', '부산'],
    'job': ['개발자', '디자이너', '개발자', 'PM', '개발자', 'PM', '디자이너', '개발자'],
    'salary': [5000, 4500, 7000, 5500, 8000, 4800, 5200, 6500]
}
df = pd.DataFrame(data)
X = df[['age', 'city', 'job']]
y = (df['salary'] > 5500).astype(int)

# CatBoost는 범주형 변수를 자동 처리
cat_features = ['city', 'job']  # 범주형 컬럼 인덱스 또는 이름

model = CatBoostClassifier(
    iterations=500,
    learning_rate=0.1,
    depth=6,  # 트리 깊이
    cat_features=cat_features,  # 범주형 피처 지정
    verbose=100
)
model.fit(X, y)

김개발 씨가 맡은 고객 이탈 예측 데이터에는 범주형 변수가 많았습니다. 고객 등급, 가입 경로, 선호 카테고리 등 문자열 데이터가 절반 이상이었습니다.

"이런 데이터는 원핫 인코딩을 해야 하나요?" 김개발 씨가 물었습니다. 박시니어 씨가 고개를 저었습니다.

"CatBoost를 쓰면 그럴 필요가 없어요." 범주형 변수 처리는 머신러닝에서 늘 골치 아픈 문제입니다. 원핫 인코딩을 하면 차원이 폭발적으로 늘어납니다.

도시 컬럼 하나에 250개 도시가 있다면, 250개의 새로운 컬럼이 생기는 것입니다. 레이블 인코딩은 어떨까요?

숫자로 바꾸긴 하지만, 순서 관계가 없는 데이터에 임의의 순서를 부여하는 문제가 있습니다. 서울이 1이고 부산이 2라고 해서 부산이 서울보다 큰 것은 아니니까요.

타겟 인코딩은 좋은 대안입니다. 각 범주를 해당 범주의 타겟 평균값으로 바꿉니다.

하지만 여기에는 치명적인 문제가 있습니다. 바로 정보 누수입니다.

쉽게 설명하면 이렇습니다. 시험 문제를 풀 때 정답지를 미리 보는 것과 같습니다.

학습 데이터의 타겟값을 사용해서 인코딩하면, 모델이 타겟 정보를 미리 알게 됩니다. 학습 성능은 좋아 보이지만, 실제 예측에서는 엉망이 됩니다.

CatBoost는 이 문제를 순서 기반 부스팅으로 해결했습니다. 각 샘플을 인코딩할 때, 그 샘플보다 앞에 있는 데이터만 사용합니다.

마치 시간 순서대로 데이터를 처리하는 것처럼요. 10번째 데이터를 인코딩할 때는 1번부터 9번까지의 정보만 사용합니다.

위의 코드를 보면, cat_features 파라미터에 범주형 컬럼을 지정하는 것만으로 끝납니다. 별도의 전처리가 필요 없습니다.

심지어 결측값도 자동으로 처리합니다. CatBoost의 또 다른 강점은 기본 성능입니다.

하이퍼파라미터 튜닝을 거의 하지 않아도 좋은 성능을 냅니다. 바쁜 실무 환경에서 이 장점은 생각보다 큽니다.

실제로 금융권에서 CatBoost를 많이 사용합니다. 신용 평가, 이상 거래 탐지 같은 업무에는 범주형 변수가 많기 때문입니다.

고객 직업, 거주 지역, 거래 유형 등 대부분이 범주형입니다. 주의할 점은 학습 속도입니다.

CatBoost는 LightGBM보다 학습이 느린 편입니다. 순서 기반 부스팅과 복잡한 범주형 처리 때문입니다.

하지만 전처리 시간까지 합치면 전체 파이프라인 시간은 비슷해질 수 있습니다. 김개발 씨가 고개를 끄덕였습니다.

"범주형 변수가 많으면 CatBoost가 유리하겠네요."

실전 팁

💡 - 범주형 변수가 많은 데이터셋에서 CatBoost의 진가가 발휘됩니다

• cat_features를 지정하지 않으면 숫자로 된 범주형 변수도 연속형으로 처리되니 주의하세요
• 기본 설정으로도 충분히 좋은 성능을 내므로, 처음에는 튜닝 없이 시작해보세요

---

4. 학습 속도 비교

"그래서 어떤 게 더 빨라요?" 김개발 씨의 당연한 질문입니다. 실무에서 모델 학습 시간은 곧 업무 효율과 직결됩니다.

한 번 학습에 1시간이 걸리는 모델과 5분이 걸리는 모델은 실험 횟수에서 엄청난 차이를 만듭니다.

학습 속도에서는 LightGBM이 대체로 우위를 점합니다. 히스토그램 기반 알고리즘과 리프 중심 분할 덕분에 대용량 데이터에서 특히 빠릅니다.

CatBoost는 범주형 변수의 자동 처리와 순서 기반 부스팅 때문에 상대적으로 느리지만, 전처리 시간을 합치면 격차가 줄어들 수 있습니다.

다음 코드를 살펴봅시다.

import lightgbm as lgb
from catboost import CatBoostClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
import time

# 대용량 데이터 생성
X, y = make_classification(n_samples=100000, n_features=50, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# LightGBM 학습 시간 측정
start = time.time()
lgb_model = lgb.LGBMClassifier(n_estimators=500, num_leaves=31, verbose=-1)
lgb_model.fit(X_train, y_train)
lgb_time = time.time() - start
print(f"LightGBM 학습 시간: {lgb_time:.2f}초")

# CatBoost 학습 시간 측정
start = time.time()
cat_model = CatBoostClassifier(iterations=500, depth=6, verbose=0)
cat_model.fit(X_train, y_train)
cat_time = time.time() - start
print(f"CatBoost 학습 시간: {cat_time:.2f}초")

print(f"LightGBM이 {cat_time/lgb_time:.1f}배 빠름")

김개발 씨는 직접 실험해보기로 했습니다. 10만 건의 데이터로 두 라이브러리의 학습 속도를 비교했습니다.

결과는 명확했습니다. LightGBM이 CatBoost보다 2배에서 5배 정도 빨랐습니다.

데이터 크기가 커질수록 이 격차는 더 벌어졌습니다. 왜 이런 차이가 날까요?

LightGBM은 히스토그램 기반 알고리즘을 사용합니다. 연속형 변수의 값을 일정 개수의 구간으로 나눕니다.

예를 들어 나이 변수가 0세부터 100세까지 있다면, 이를 256개의 구간으로 나눕니다. 이렇게 하면 분할점을 찾을 때 모든 값을 비교할 필요가 없습니다.

마치 도서관에서 책을 찾을 때와 같습니다. 모든 책을 하나씩 살펴보는 것보다, 먼저 분류 코드로 구역을 좁히는 것이 훨씬 빠릅니다.

또한 LightGBM은 병렬 처리에 최적화되어 있습니다. 여러 개의 CPU 코어를 동시에 활용합니다.

데이터를 특성별로 나누어 병렬로 최적 분할점을 찾습니다. 반면 CatBoost는 순서 기반 부스팅 때문에 병렬화에 제약이 있습니다.

순서가 중요하기 때문에 완전한 병렬 처리가 어렵습니다. 하지만 여기서 중요한 점이 있습니다.

전체 파이프라인 시간을 봐야 합니다. LightGBM을 쓰려면 범주형 변수를 미리 인코딩해야 합니다.

원핫 인코딩이든 레이블 인코딩이든 추가 작업이 필요합니다. 반면 CatBoost는 원본 데이터를 그대로 넣을 수 있습니다.

실무에서 범주형 변수가 20개 있고, 각각 수백 개의 범주가 있다고 생각해보세요. 인코딩 작업만 해도 상당한 시간이 걸립니다.

게다가 인코딩 방식에 따라 결과도 달라지니 여러 번 실험해야 합니다. GPU 환경에서는 또 다릅니다.

CatBoost의 GPU 구현이 상당히 효율적입니다. GPU를 사용하면 CatBoost와 LightGBM의 속도 차이가 많이 줄어듭니다.

결론적으로, 순수 학습 속도만 보면 LightGBM이 빠릅니다. 하지만 범주형 변수가 많은 데이터에서 전체 작업 시간을 고려하면 CatBoost도 경쟁력이 있습니다.

김개발 씨가 정리했습니다. "속도가 중요하면 LightGBM, 범주형 데이터가 많으면 CatBoost를 고려하면 되겠네요."

실전 팁

💡 - 빠른 실험이 필요한 캐글 대회에서는 LightGBM으로 먼저 베이스라인을 잡으세요

• GPU가 있다면 CatBoost의 task_type='GPU' 옵션을 활용해보세요
• 학습 시간뿐 아니라 전처리와 피처 엔지니어링 시간까지 고려하여 선택하세요

---

5. 범주형 변수 처리 비교

김개발 씨의 고객 데이터에는 범주형 변수가 12개나 있었습니다. 고객 등급, 가입 채널, 선호 결제 수단, 거주 지역 등등.

각 변수마다 범주가 수십 개씩 됩니다. "이걸 어떻게 처리해야 할까요?" 범주형 변수 처리는 실무에서 가장 까다로운 문제 중 하나입니다.

범주형 변수 처리는 두 라이브러리의 가장 큰 차이점입니다. CatBoost는 범주형 변수를 네이티브로 지원하여 별도 인코딩 없이 사용할 수 있습니다.

순서 기반 타겟 인코딩으로 정보 누수를 방지합니다. LightGBM도 범주형 변수를 지원하지만, 정수 인코딩이 필요하며 CatBoost만큼 세련되지 않습니다.

다음 코드를 살펴봅시다.

import pandas as pd
import lightgbm as lgb
from catboost import CatBoostClassifier
from sklearn.preprocessing import LabelEncoder

# 범주형 변수가 많은 데이터
data = pd.DataFrame({
    'channel': ['웹', '앱', '매장', '앱', '웹', '매장', '앱', '웹'],
    'grade': ['골드', '실버', '브론즈', '골드', '골드', '실버', '브론즈', '골드'],
    'region': ['서울', '경기', '부산', '서울', '대전', '경기', '서울', '부산'],
    'purchase': [150000, 80000, 50000, 200000, 120000, 90000, 60000, 180000]
})
y = (data['purchase'] > 100000).astype(int)
X = data[['channel', 'grade', 'region']]

# CatBoost: 그대로 사용 가능
cat_model = CatBoostClassifier(iterations=100, verbose=0)
cat_model.fit(X, y, cat_features=['channel', 'grade', 'region'])

# LightGBM: 레이블 인코딩 필요
X_encoded = X.copy()
encoders = {}
for col in ['channel', 'grade', 'region']:
    encoders[col] = LabelEncoder()
    X_encoded[col] = encoders[col].fit_transform(X[col])

lgb_model = lgb.LGBMClassifier(n_estimators=100, verbose=-1)
lgb_model.fit(X_encoded, y, categorical_feature=['channel', 'grade', 'region'])

박시니어 씨가 화이트보드에 두 가지 방식을 그렸습니다. "범주형 변수 처리에서 두 라이브러리의 철학이 완전히 다릅니다." 먼저 CatBoost의 방식을 살펴봅시다.

CatBoost는 문자열 범주형 데이터를 그대로 받습니다. 내부적으로 순서 기반 타겟 인코딩을 수행합니다.

각 샘플을 처리할 때, 이전에 나온 같은 범주의 타겟 평균을 사용합니다. 예를 들어 설명하면 이렇습니다.

다섯 번째 "서울" 데이터를 인코딩한다고 합시다. 이때 앞에 나온 네 개의 "서울" 데이터의 타겟 평균을 계산합니다.

다섯 번째 데이터 자신의 타겟값은 사용하지 않습니다. 이렇게 하면 정보 누수가 발생하지 않습니다.

마치 주식 예측과 같습니다. 내일 주가를 예측할 때 오늘까지의 데이터만 사용해야 합니다.

내일 데이터를 미리 알고 예측하면 반칙이죠. LightGBM의 방식은 다릅니다.

LightGBM도 categorical_feature 옵션을 지원합니다. 하지만 먼저 정수로 인코딩해야 합니다.

"서울"은 0, "부산"은 1, "대전"은 2 이런 식으로요. 그 후에 LightGBM이 내부적으로 범주형으로 처리합니다.

문제는 새로운 범주가 나타났을 때입니다. 학습 데이터에 없던 "제주"가 테스트 데이터에 나타나면 어떻게 될까요?

LightGBM의 LabelEncoder는 에러를 발생시킵니다. 본 적 없는 범주는 처리할 수 없기 때문입니다.

실무에서 이런 상황은 자주 발생합니다. 새로운 지역이 추가되거나, 새로운 상품 카테고리가 생기는 경우죠.

CatBoost는 이런 상황에 더 강건합니다. 새로운 범주가 나타나면 기본값으로 처리합니다.

물론 정확도가 떨어질 수 있지만, 최소한 에러는 발생하지 않습니다. 코드를 보면 차이가 명확합니다.

CatBoost는 X를 그대로 사용합니다. LightGBM은 X_encoded를 만들기 위해 LabelEncoder를 적용해야 합니다.

코드 양도 다르고, 유지보수 포인트도 늘어납니다. 실무에서 이 차이는 생각보다 큽니다.

데이터 파이프라인이 복잡해질수록, 인코딩 로직을 관리하는 것이 부담이 됩니다. 학습할 때 쓴 인코더를 예측할 때도 똑같이 적용해야 하니까요.

김개발 씨가 물었습니다. "그럼 범주형 변수가 많으면 무조건 CatBoost가 좋은 건가요?" 박시니어 씨가 대답했습니다.

"대체로 그렇지만, 항상은 아니에요. 성능은 결국 데이터에 따라 다르거든요."

실전 팁

💡 - 범주형 변수가 많고 범주 개수도 많다면 CatBoost를 먼저 고려하세요

• LightGBM을 쓸 때는 새로운 범주 처리 로직을 미리 준비해두세요
• 범주형 변수의 카디널리티가 매우 높으면 두 라이브러리 모두 성능이 저하될 수 있습니다

---

6. 하이퍼파라미터 튜닝 전략

모델을 선택했다면 다음은 하이퍼파라미터 튜닝입니다. 김개발 씨는 옵티마이저 라이브러리를 설치하고 수십 개의 파라미터를 조합해보기 시작했습니다.

그런데 선배가 멈추라고 합니다. "잠깐, 모든 파라미터를 다 튜닝할 필요는 없어요."

하이퍼파라미터 튜닝은 모델 성능을 끌어올리는 핵심 과정입니다. LightGBM은 num_leaves, learning_rate, max_depth가 핵심 파라미터입니다.

CatBoost는 기본 설정으로도 좋은 성능을 내지만, depth와 l2_leaf_reg 튜닝으로 추가 개선이 가능합니다. 두 라이브러리 모두 early_stopping을 활용하면 효율적인 튜닝이 가능합니다.

다음 코드를 살펴봅시다.

import optuna
import lightgbm as lgb
from catboost import CatBoostClassifier
from sklearn.model_selection import cross_val_score
from sklearn.datasets import make_classification

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

# LightGBM 튜닝 예제
def lgb_objective(trial):
    params = {
        'n_estimators': 1000,
        'num_leaves': trial.suggest_int('num_leaves', 20, 150),
        'learning_rate': trial.suggest_float('learning_rate', 0.01, 0.3),
        'max_depth': trial.suggest_int('max_depth', 3, 12),
        'min_child_samples': trial.suggest_int('min_child_samples', 5, 100),
        '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),
        'verbose': -1
    }
    model = lgb.LGBMClassifier(**params)
    scores = cross_val_score(model, X, y, cv=3, scoring='roc_auc')
    return scores.mean()

# Optuna로 최적화
study = optuna.create_study(direction='maximize')
study.optimize(lgb_objective, n_trials=50, show_progress_bar=True)
print(f"최적 파라미터: {study.best_params}")

김개발 씨가 하이퍼파라미터 튜닝을 시작하려는데, 박시니어 씨가 조언했습니다. "모든 파라미터를 다 건드리면 시간만 낭비해요.

핵심만 튜닝하세요." LightGBM의 핵심 파라미터를 알아봅시다. 가장 중요한 것은 num_leaves입니다.

이 값이 모델의 복잡도를 결정합니다. 값이 크면 더 복잡한 패턴을 학습하지만 과적합 위험이 있습니다.

값이 작으면 단순한 모델이 되어 과소적합이 될 수 있습니다. 그 다음은 learning_rate입니다.

보통 0.01에서 0.3 사이에서 찾습니다. learning_rate가 작으면 더 많은 트리가 필요하지만 정밀한 학습이 가능합니다.

시간이 없다면 0.1 정도로 시작하는 것이 좋습니다. max_depth는 각 트리의 최대 깊이입니다.

LightGBM에서는 num_leaves와 함께 조절해야 합니다. num_leaves를 31로 설정했다면, max_depth는 5 정도가 적당합니다.

정규화 파라미터인 reg_alpha와 reg_lambda도 중요합니다. 과적합을 방지하는 역할을 합니다.

특히 피처가 많거나 노이즈가 많은 데이터에서 효과적입니다. CatBoost의 튜닝 전략은 조금 다릅니다.

CatBoost의 기본 설정은 이미 상당히 최적화되어 있습니다. 따라서 튜닝의 효과가 LightGBM보다 적을 수 있습니다.

그래도 튜닝한다면 depth와 l2_leaf_reg를 먼저 건드리세요. 위 코드에서 Optuna를 사용했습니다.

베이지안 최적화 기반의 하이퍼파라미터 튜닝 라이브러리입니다. 랜덤 서치보다 효율적으로 좋은 파라미터를 찾아줍니다.

실무 팁을 하나 드리자면, 처음부터 많은 trial을 돌리지 마세요. 먼저 10회 정도로 대략적인 범위를 파악합니다.

그 후에 범위를 좁혀서 다시 튜닝합니다. 이렇게 하면 시간을 절약할 수 있습니다.

early_stopping도 필수입니다. 검증 성능이 더 이상 좋아지지 않으면 학습을 중단합니다.

불필요한 학습 시간을 줄이고 과적합도 방지합니다. 김개발 씨가 이해했다는 표정을 지었습니다.

"핵심 파라미터 몇 개만 집중적으로 튜닝하면 되는군요."

실전 팁

💡 - LightGBM은 num_leaves, learning_rate, max_depth를 우선 튜닝하세요

• CatBoost는 기본 설정으로 먼저 결과를 보고, 필요시 depth와 l2_leaf_reg를 조절하세요
• 하이퍼파라미터 튜닝보다 피처 엔지니어링에 시간을 더 투자하는 것이 효과적입니다

---

7. 과적합 방지 기법

김개발 씨의 모델이 학습 데이터에서는 AUC 0.98을 기록했습니다. 하지만 검증 데이터에서는 0.75밖에 안 나왔습니다.

전형적인 과적합입니다. "학습 데이터를 너무 잘 외워버린 거예요." 박시니어 씨가 진단했습니다.

과적합은 모델이 학습 데이터의 노이즈까지 학습하여 새로운 데이터에서 성능이 떨어지는 현상입니다. LightGBM과 CatBoost 모두 다양한 과적합 방지 기법을 제공합니다.

early_stopping, 정규화, 샘플링 기법 등을 적절히 조합하면 일반화 성능을 크게 높일 수 있습니다.

다음 코드를 살펴봅시다.

import lightgbm as lgb
from catboost import CatBoostClassifier
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_classification

X, y = make_classification(n_samples=10000, n_features=50,
                           n_informative=10, random_state=42)
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2)

# LightGBM 과적합 방지 설정
lgb_model = lgb.LGBMClassifier(
    n_estimators=2000,
    num_leaves=31,
    learning_rate=0.05,
    reg_alpha=0.1,  # L1 정규화
    reg_lambda=0.1,  # L2 정규화
    min_child_samples=20,  # 리프 노드 최소 샘플 수
    feature_fraction=0.8,  # 피처 서브샘플링
    bagging_fraction=0.8,  # 데이터 서브샘플링
    bagging_freq=5,  # 배깅 주기
    verbose=-1
)
lgb_model.fit(X_train, y_train, eval_set=[(X_val, y_val)],
              callbacks=[lgb.early_stopping(100, verbose=False)])

# CatBoost 과적합 방지 설정
cat_model = CatBoostClassifier(
    iterations=2000,
    depth=6,
    learning_rate=0.05,
    l2_leaf_reg=3,  # L2 정규화
    random_strength=1,  # 랜덤 분할 강도
    bagging_temperature=1,  # 베이지안 배깅
    verbose=0
)
cat_model.fit(X_train, y_train, eval_set=(X_val, y_val), early_stopping_rounds=100)

과적합은 마치 시험 문제를 통째로 외우는 것과 같습니다. 똑같은 문제가 나오면 100점을 맞지만, 조금만 바뀌어도 못 풀게 됩니다.

우리가 원하는 것은 문제 풀이 원리를 이해하는 것이지, 답을 외우는 것이 아닙니다. early_stopping은 가장 기본적인 과적합 방지 기법입니다.

학습 도중 검증 데이터의 성능을 계속 모니터링합니다. 성능이 더 이상 좋아지지 않으면 학습을 중단합니다.

위 코드에서 early_stopping_rounds=100은 100번의 반복 동안 성능 향상이 없으면 멈추라는 의미입니다. 정규화는 모델이 너무 복잡해지는 것을 막습니다.

LightGBM의 reg_alpha는 L1 정규화입니다. 불필요한 피처의 가중치를 0으로 만들어 피처 선택 효과가 있습니다.

reg_lambda는 L2 정규화입니다. 가중치가 너무 커지는 것을 막아 모델을 부드럽게 만듭니다.

CatBoost의 l2_leaf_reg도 같은 역할을 합니다. 리프 노드의 출력값에 정규화를 적용합니다.

샘플링 기법도 효과적입니다. feature_fraction=0.8은 각 트리를 만들 때 80%의 피처만 랜덤으로 사용합니다.

bagging_fraction=0.8은 80%의 데이터만 사용합니다. 이렇게 하면 각 트리가 조금씩 다른 관점에서 학습하게 됩니다.

마치 여러 명의 전문가가 의견을 내는 것과 같습니다. 한 사람이 모든 정보를 가지고 판단하는 것보다, 여러 사람이 일부 정보로 판단한 결과를 종합하는 것이 더 정확할 수 있습니다.

CatBoost의 bagging_temperature는 독특한 파라미터입니다. 베이지안 부트스트랩을 사용하여 샘플 가중치를 조절합니다.

값이 클수록 더 다양한 샘플 조합을 만들어냅니다. min_child_samples도 중요합니다.

리프 노드에 최소한 이만큼의 샘플이 있어야 분할합니다. 값이 너무 작으면 노이즈에 민감해지고, 너무 크면 패턴을 놓칠 수 있습니다.

보통 20에서 100 사이에서 설정합니다. 실무에서 과적합 여부를 확인하는 가장 쉬운 방법은 학습 곡선을 그려보는 것입니다.

학습 손실은 계속 줄어드는데 검증 손실이 늘어나기 시작하면, 그 지점이 과적합의 시작입니다. 김개발 씨가 설정을 적용하고 다시 학습했습니다.

이번에는 학습 AUC 0.87, 검증 AUC 0.84가 나왔습니다. 격차가 훨씬 줄어들었습니다.

실전 팁

💡 - early_stopping은 무조건 사용하세요. 과적합 방지와 학습 시간 단축 두 마리 토끼를 잡습니다

• 정규화 강도는 검증 성능을 보면서 조절하세요
• 학습과 검증 성능 차이가 10% 이상이면 과적합을 의심하세요

---

8. 실전 모델 선택 가이드

김개발 씨가 일주일간 두 라이브러리를 공부했습니다. 이제 실제 프로젝트에 적용할 차례입니다.

"결국 어떤 걸 써야 할까요?" 이것이 가장 현실적인 질문입니다. 정답은 상황에 따라 다르지만, 몇 가지 기준을 세워볼 수 있습니다.

모델 선택은 데이터 특성, 프로젝트 요구사항, 인프라 환경을 종합적으로 고려해야 합니다. 범주형 변수가 많다면 CatBoost가 유리합니다.

속도가 중요하고 데이터가 크다면 LightGBM을 선택하세요. 빠른 실험과 반복이 필요한 캐글 대회에서는 LightGBM으로 시작하고, 최종 앙상블에 CatBoost를 추가하는 전략이 효과적입니다.

다음 코드를 살펴봅시다.

# 상황별 모델 선택 의사결정 코드
def recommend_model(data_info):
    """
    데이터 특성에 따른 모델 추천
    """
    n_samples = data_info['n_samples']
    n_categorical = data_info['n_categorical']
    n_features = data_info['n_features']
    has_gpu = data_info.get('has_gpu', False)
    time_sensitive = data_info.get('time_sensitive', False)

    score = {'lightgbm': 0, 'catboost': 0}
    reasons = []

    # 데이터 크기 기준
    if n_samples > 100000:
        score['lightgbm'] += 2
        reasons.append("대용량 데이터: LightGBM이 빠름")

    # 범주형 변수 비율
    cat_ratio = n_categorical / n_features if n_features > 0 else 0
    if cat_ratio > 0.3:
        score['catboost'] += 3
        reasons.append("범주형 변수 많음: CatBoost 유리")

    # 시간 제약
    if time_sensitive:
        score['lightgbm'] += 2
        reasons.append("시간 제약: LightGBM 선택")

    # GPU 환경
    if has_gpu:
        score['catboost'] += 1
        reasons.append("GPU 환경: CatBoost도 경쟁력 있음")

    winner = 'lightgbm' if score['lightgbm'] >= score['catboost'] else 'catboost'
    return {'recommendation': winner, 'reasons': reasons, 'scores': score}

# 사용 예시
result = recommend_model({
    'n_samples': 50000, 'n_categorical': 15,
    'n_features': 30, 'time_sensitive': False
})
print(f"추천: {result['recommendation']}")

박시니어 씨가 정리해주었습니다. "모델 선택에 정답은 없어요.

하지만 몇 가지 가이드라인은 있죠." LightGBM을 선택해야 하는 경우를 먼저 봅시다. 첫째, 데이터가 매우 클 때입니다.

100만 건 이상의 데이터에서 LightGBM의 속도 장점이 빛납니다. 학습 시간이 짧으니 더 많은 실험을 할 수 있습니다.

둘째, 빠른 프로토타이핑이 필요할 때입니다. 캐글 대회나 해커톤에서는 제한된 시간 안에 많은 실험을 해야 합니다.

LightGBM으로 베이스라인을 빠르게 잡을 수 있습니다. 셋째, 피처가 대부분 수치형일 때입니다.

범주형 변수가 적다면 인코딩 부담이 크지 않습니다. LightGBM의 속도 장점을 그대로 누릴 수 있습니다.

CatBoost를 선택해야 하는 경우도 있습니다. 첫째, 범주형 변수가 많을 때입니다.

전체 피처의 30% 이상이 범주형이라면 CatBoost를 강력히 추천합니다. 인코딩 작업이 줄어들고, 정보 누수 걱정도 없습니다.

둘째, 튜닝에 시간을 쏟기 어려울 때입니다. CatBoost의 기본 설정은 이미 잘 최적화되어 있습니다.

바쁜 실무 환경에서 큰 장점입니다. 셋째, 새로운 범주가 자주 등장하는 서비스일 때입니다.

신규 상품, 신규 지역 등이 계속 추가되는 환경에서 CatBoost가 더 안정적입니다. 둘 다 쓰는 전략도 있습니다.

앙상블에서 다양성은 힘입니다. LightGBM과 CatBoost는 서로 다른 방식으로 학습하기 때문에, 둘의 예측을 결합하면 더 좋은 결과를 얻을 수 있습니다.

캐글 상위권 솔루션에서 이 전략을 자주 볼 수 있습니다. 실제로 어떻게 할까요?

LightGBM으로 빠르게 피처 엔지니어링과 데이터 탐색을 합니다. 좋은 피처를 찾았다면 CatBoost로도 학습합니다.

최종적으로 두 모델의 예측을 평균내거나 스태킹합니다. 김개발 씨가 자신의 프로젝트를 분석했습니다.

고객 데이터 5만 건, 범주형 변수 12개, 전체 피처 30개. 범주형 비율이 40%입니다.

"CatBoost로 시작하는 게 좋겠네요." 박시니어 씨가 덧붙였습니다. "좋은 판단이에요.

하지만 LightGBM도 한 번 돌려보세요. 두 결과를 비교하면 더 좋은 인사이트를 얻을 수 있어요."

실전 팁

💡 - 처음에는 두 라이브러리 모두 기본 설정으로 실험해보세요

• 범주형 변수 처리에 자신이 없다면 CatBoost로 시작하세요
• 최종 제출이나 배포 전에는 둘 다 시도해보고 앙상블을 고려하세요

---

이상으로 학습을 마칩니다. 위 내용을 직접 코드로 작성해보면서 익혀보세요!