095 FLAML vs PyCaret 심층 비교

키워드: PyCaret, 비교, AutoML, 프레임워크

개요

FLAML과 PyCaret은 모두 인기 있는 Python AutoML 라이브러리입니다. 이 글에서는 두 프레임워크의 철학, 기능, 성능을 비교하여 적합한 선택을 도와드립니다.

실습 환경

• Python 버전: 3.11 권장
• 필요 패키지: flaml[automl], pycaret

pip install flaml[automl] pycaret pandas numpy scikit-learn

기본 철학 비교

import pandas as pd

philosophy = {
    '항목': ['개발사', '철학', '주요 강점', '학습 곡선', '문서화'],
    'FLAML': [
        'Microsoft Research',
        '효율적 탐색, 최소 리소스',
        '속도, 리소스 효율성',
        '낮음 (단순 API)',
        '양호'
    ],
    'PyCaret': [
        '커뮤니티 주도',
        '로우코드, 엔드투엔드',
        '사용 편의성, 시각화',
        '매우 낮음',
        '매우 좋음'
    ]
}

print("=== 기본 철학 비교 ===")
print(pd.DataFrame(philosophy).to_string(index=False))

동일 데이터셋 비교 실험

import numpy as np
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, f1_score, roc_auc_score
import time

# 095 데이터 준비
np.random.seed(42)
X, y = make_classification(n_samples=5000, n_features=20, n_informative=15,
                           n_redundant=3, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 095 DataFrame 변환 (PyCaret용)
feature_cols = [f'f{i}' for i in range(20)]
train_df = pd.DataFrame(X_train, columns=feature_cols)
train_df['target'] = y_train
test_df = pd.DataFrame(X_test, columns=feature_cols)
test_df['target'] = y_test

print(f"학습 데이터: {len(train_df)}행, 테스트 데이터: {len(test_df)}행")

FLAML 실험

from flaml import AutoML

# 095 FLAML 학습
print("\n=== FLAML 실험 ===")
flaml_start = time.time()

flaml_automl = AutoML()
flaml_automl.fit(
    X_train, y_train,
    task="classification",
    time_budget=60,
    metric="accuracy",
    verbose=0
)

flaml_time = time.time() - flaml_start

# 095 예측 및 평가
flaml_pred = flaml_automl.predict(X_test)
flaml_proba = flaml_automl.predict_proba(X_test)[:, 1]

flaml_results = {
    'accuracy': accuracy_score(y_test, flaml_pred),
    'f1': f1_score(y_test, flaml_pred),
    'roc_auc': roc_auc_score(y_test, flaml_proba),
    'time': flaml_time,
    'best_model': flaml_automl.best_estimator
}

print(f"최적 모델: {flaml_results['best_model']}")
print(f"정확도: {flaml_results['accuracy']:.4f}")
print(f"학습 시간: {flaml_results['time']:.1f}초")

PyCaret 실험

# 095 PyCaret 학습
print("\n=== PyCaret 실험 ===")

# 095 PyCaret은 setup → compare_models 흐름
# 095 실제 실행을 위한 코드 (주석 처리)
"""
from pycaret.classification import setup, compare_models, predict_model, pull

pycaret_start = time.time()

# 095 환경 설정
clf = setup(
    data=train_df,
    target='target',
    session_id=42,
    verbose=False,
    html=False
)

# 095 모델 비교 (상위 3개)
best_model = compare_models(n_select=1, budget_time=1)  # 1분

pycaret_time = time.time() - pycaret_start

# 095 예측
predictions = predict_model(best_model, data=test_df)
pycaret_pred = predictions['prediction_label'].values
pycaret_proba = predictions['prediction_score'].values

pycaret_results = {
    'accuracy': accuracy_score(y_test, pycaret_pred),
    'f1': f1_score(y_test, pycaret_pred),
    'roc_auc': roc_auc_score(y_test, pycaret_proba),
    'time': pycaret_time,
    'best_model': type(best_model).__name__
}
"""

# 095 시뮬레이션 결과 (실제 결과는 환경에 따라 다름)
pycaret_results = {
    'accuracy': 0.924,
    'f1': 0.923,
    'roc_auc': 0.978,
    'time': 65.2,
    'best_model': 'LightGBM'
}

print(f"최적 모델: {pycaret_results['best_model']}")
print(f"정확도: {pycaret_results['accuracy']:.4f}")
print(f"학습 시간: {pycaret_results['time']:.1f}초")

결과 비교

# 095 결과 비교 테이블
comparison = {
    '지표': ['Accuracy', 'F1 Score', 'ROC-AUC', '학습 시간(초)', '최적 모델'],
    'FLAML': [
        f"{flaml_results['accuracy']:.4f}",
        f"{flaml_results['f1']:.4f}",
        f"{flaml_results['roc_auc']:.4f}",
        f"{flaml_results['time']:.1f}",
        flaml_results['best_model']
    ],
    'PyCaret': [
        f"{pycaret_results['accuracy']:.4f}",
        f"{pycaret_results['f1']:.4f}",
        f"{pycaret_results['roc_auc']:.4f}",
        f"{pycaret_results['time']:.1f}",
        pycaret_results['best_model']
    ]
}

print("\n=== 성능 비교 ===")
print(pd.DataFrame(comparison).to_string(index=False))

기능 비교

features = {
    '기능': [
        '분류', '회귀', '시계열',
        '하이퍼파라미터 최적화', '앙상블',
        '특성 공학', '전처리 자동화',
        '시각화', 'MLflow 통합',
        'GPU 지원', '대용량 데이터'
    ],
    'FLAML': [
        '✓', '✓', '✓',
        '✓ (CFO/BlendSearch)', '✓',
        '제한적', '제한적',
        '제한적', '✓',
        '✓', '✓ (효율적)'
    ],
    'PyCaret': [
        '✓', '✓', '✓',
        '✓ (tune_model)', '✓ (blend/stack)',
        '✓', '✓ (자동)',
        '✓ (풍부)', '✓',
        '✓', '△ (메모리 집약)'
    ]
}

print("\n=== 기능 비교 ===")
print(pd.DataFrame(features).to_string(index=False))

API 스타일 비교

api_comparison = """
=== API 스타일 비교 ===

### FLAML 방식 (함수형)
```python
from flaml import AutoML

automl = AutoML()
automl.fit(X_train, y_train, task="classification", time_budget=60)
predictions = automl.predict(X_test)

PyCaret 방식 (파이프라인형)

from pycaret.classification import *

setup(data=train_df, target='target')
best = compare_models()
tuned = tune_model(best)
final = finalize_model(tuned)
predictions = predict_model(final, data=test_df)

"""

print(api_comparison)

## 사용 시나리오별 추천

```python
scenarios = {
    '시나리오': [
        'EDA 및 프로토타이핑',
        '빠른 베이스라인',
        '대용량 데이터',
        '리소스 제한 환경',
        '비기술 팀 협업',
        '프로덕션 배포',
        '커스텀 모델 통합',
        '시계열 예측'
    ],
    '추천': [
        'PyCaret',
        '둘 다 좋음',
        'FLAML',
        'FLAML',
        'PyCaret',
        '둘 다 좋음',
        'FLAML',
        'PyCaret (더 많은 옵션)'
    ],
    '이유': [
        '풍부한 시각화',
        '비슷한 학습 곡선',
        '메모리 효율',
        'CFO 알고리즘',
        'low-code 접근',
        '둘 다 MLflow 지원',
        '유연한 estimator_list',
        'Prophet, ARIMA 등 지원'
    ]
}

print("\n=== 시나리오별 추천 ===")
print(pd.DataFrame(scenarios).to_string(index=False))

장단점 요약

flaml_pros_cons = """
=== FLAML 장단점 ===

장점:
✓ 빠른 수렴 (CFO 알고리즘)
✓ 메모리 효율적
✓ 간단한 API
✓ 커스텀 모델 쉬운 통합
✓ LLM 파인튜닝 지원

단점:
✗ 시각화 기능 제한적
✗ 전처리 자동화 미흡
✗ 커뮤니티 크기 작음
"""

pycaret_pros_cons = """
=== PyCaret 장단점 ===

장점:
✓ 직관적인 워크플로우
✓ 풍부한 시각화
✓ 자동 전처리
✓ 상세한 문서화
✓ 활발한 커뮤니티

단점:
✗ 메모리 사용량 높음
✗ 대용량 데이터 처리 느림
✗ 세부 제어 어려움
"""

print(flaml_pros_cons)
print(pycaret_pros_cons)

하이브리드 접근법

def hybrid_automl_pipeline(X_train, y_train, X_test, y_test):
    """FLAML과 PyCaret을 함께 활용하는 파이프라인"""
    results = {}

    # 1. FLAML로 빠른 베이스라인
    print("1. FLAML 빠른 탐색...")
    flaml_quick = AutoML()
    flaml_quick.fit(X_train, y_train, task="classification",
                    time_budget=30, verbose=0)

    flaml_pred = flaml_quick.predict(X_test)
    results['flaml_baseline'] = {
        'model': flaml_quick.best_estimator,
        'accuracy': accuracy_score(y_test, flaml_pred)
    }

    # 2. FLAML 결과로 유망한 모델 타입 파악
    promising_models = [flaml_quick.best_estimator]
    print(f"   유망 모델: {promising_models}")

    # 3. PyCaret으로 상세 분석 (시뮬레이션)
    # 실제로는 PyCaret으로 include_models 설정
    """
    from pycaret.classification import setup, compare_models

    setup(data=train_df, target='target',
          include=[flaml_quick.best_estimator])
    best = compare_models()
    """

    results['hybrid_approach'] = "FLAML 탐색 → PyCaret 정제"

    return results

# 095 하이브리드 실행
hybrid_results = hybrid_automl_pipeline(X_train, y_train, X_test, y_test)
print(f"\n하이브리드 결과: {hybrid_results}")

선택 가이드 플로차트

selection_guide = """
=== AutoML 선택 가이드 ===

시작
  │
  ├─ 데이터 크기 > 1GB?
  │    ├─ Yes → FLAML (메모리 효율)
  │    └─ No ↓
  │
  ├─ 시각화/리포트 중요?
  │    ├─ Yes → PyCaret (풍부한 시각화)
  │    └─ No ↓
  │
  ├─ 빠른 프로토타이핑?
  │    ├─ Yes → 둘 다 OK (PyCaret 살짝 유리)
  │    └─ No ↓
  │
  ├─ 커스텀 모델 필요?
  │    ├─ Yes → FLAML (유연한 통합)
  │    └─ No ↓
  │
  └─ 팀원이 비개발자?
       ├─ Yes → PyCaret (low-code)
       └─ No → FLAML (효율성)
"""

print(selection_guide)

정리

• FLAML: 효율성, 속도, 리소스 최적화에 강점
• PyCaret: 사용 편의성, 시각화, 워크플로우에 강점
• 선택 기준: 데이터 크기, 팀 구성, 프로젝트 요구사항
• 하이브리드: 두 도구를 함께 활용하면 시너지 효과

다음 글 예고

다음 글에서는 FLAML vs Auto-sklearn 비교를 진행합니다. 또 다른 인기 AutoML 프레임워크와의 차이점을 분석합니다.

---

FLAML AutoML 마스터 시리즈 #095