014 학습 로그 분석하기

키워드: 로그, 분석

개요

FLAML 학습 과정을 이해하려면 로그 분석이 필수입니다. 어떤 모델이 어떤 순서로 탐색되었는지, 각 반복에서 어떤 성능을 보였는지 로그를 통해 확인할 수 있습니다.

이 글에서는 FLAML 로그를 설정하고, 파일로 저장하고, 분석하는 방법을 알아봅니다.

실습 환경

• Python 버전: 3.11 권장
• 필요 패키지: flaml[automl], pandas, scikit-learn

pip install flaml[automl] pandas scikit-learn

로그 레벨 설정

verbose 파라미터

verbose 파라미터로 로그 출력 수준을 조절합니다.

from flaml import AutoML
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

verbose=0 (로그 없음)

automl = AutoML()
automl.fit(
    X_train, y_train,
    task="classification",
    time_budget=30,
    verbose=0  # 로그 출력 없음
)
print(f"최적 모델: {automl.best_estimator}")

verbose=1 (기본 로그)

automl = AutoML()
automl.fit(
    X_train, y_train,
    task="classification",
    time_budget=30,
    verbose=1  # 기본 로그
)

실행 결과 (verbose=1)

[flaml.automl.logger: INFO] Iteration 1, current learner lgbm
[flaml.automl.logger: INFO] at 0.2s, best lgbm's error=0.0330, best lgbm's error=0.0330
[flaml.automl.logger: INFO] Iteration 2, current learner lgbm
[flaml.automl.logger: INFO] at 0.3s, best lgbm's error=0.0308, best lgbm's error=0.0308
...

verbose=2 (상세 로그)

automl = AutoML()
automl.fit(
    X_train, y_train,
    task="classification",
    time_budget=30,
    verbose=2  # 상세 로그
)

실행 결과 (verbose=2)

[flaml.automl.logger: DEBUG] sample_size: 120
[flaml.automl.logger: DEBUG] Estimated time for lgbm: 0.0s
[flaml.automl.logger: INFO] Iteration 1, current learner lgbm
[flaml.automl.logger: DEBUG] config: {'n_estimators': 4, 'num_leaves': 4, ...}
[flaml.automl.logger: INFO] at 0.2s, best lgbm's error=0.0330
...

로그 파일 저장

log_file_name 파라미터

학습 로그를 파일로 저장합니다.

automl = AutoML()
automl.fit(
    X_train, y_train,
    task="classification",
    time_budget=60,
    log_file_name="flaml_training.log",  # 로그 파일
    verbose=1
)

print("로그 파일 저장 완료: flaml_training.log")

로그 파일 내용 확인

# 014 로그 파일 읽기
with open("flaml_training.log", "r") as f:
    log_content = f.read()

print("로그 파일 내용 (처음 2000자):")
print(log_content[:2000])

로그 파일 분석

JSON 형식 로그 파싱

FLAML 로그는 JSON 형식으로 각 반복 정보를 기록합니다.

import json
import pandas as pd

def parse_flaml_log(log_file):
    """FLAML 로그 파일을 파싱하여 DataFrame으로 변환"""
    records = []

    with open(log_file, 'r') as f:
        for line in f:
            try:
                record = json.loads(line)
                records.append(record)
            except json.JSONDecodeError:
                continue

    if records:
        df = pd.DataFrame(records)
        return df
    return None

# 014 로그 파싱
log_df = parse_flaml_log("flaml_training.log")

if log_df is not None:
    print(f"총 {len(log_df)}개의 반복 기록")
    print(f"\n컬럼: {log_df.columns.tolist()}")
    print(f"\n처음 5개 기록:")
    print(log_df.head())

주요 로그 필드

필드	설명
curr_learner	현재 탐색 중인 모델
best_learner	현재까지 최적 모델
val_loss	검증 손실
best_loss	최적 검증 손실
wall_clock_time	경과 시간
config	하이퍼파라미터 설정
sample_size	샘플 크기

로그 시각화

학습 곡선 그리기

import matplotlib.pyplot as plt

def plot_learning_curve(log_file):
    """학습 곡선 시각화"""
    log_df = parse_flaml_log(log_file)

    if log_df is None or 'wall_clock_time' not in log_df.columns:
        print("로그를 파싱할 수 없습니다.")
        return

    plt.figure(figsize=(12, 5))

    # 검증 손실 추이
    plt.subplot(1, 2, 1)
    if 'val_loss' in log_df.columns:
        plt.plot(log_df['wall_clock_time'], log_df['val_loss'], 'b-', alpha=0.5, label='val_loss')
    if 'best_loss' in log_df.columns:
        plt.plot(log_df['wall_clock_time'], log_df['best_loss'], 'r-', linewidth=2, label='best_loss')
    plt.xlabel('시간 (초)')
    plt.ylabel('손실')
    plt.title('학습 곡선')
    plt.legend()
    plt.grid(True, alpha=0.3)

    # 모델별 탐색 횟수
    plt.subplot(1, 2, 2)
    if 'curr_learner' in log_df.columns:
        learner_counts = log_df['curr_learner'].value_counts()
        plt.bar(learner_counts.index, learner_counts.values)
        plt.xlabel('모델')
        plt.ylabel('탐색 횟수')
        plt.title('모델별 탐색 횟수')
        plt.xticks(rotation=45)

    plt.tight_layout()
    plt.savefig('learning_curve.png', dpi=100)
    plt.show()

# 014 시각화
plot_learning_curve("flaml_training.log")

모델별 성능 비교

def plot_model_performance(log_file):
    """모델별 최적 성능 시각화"""
    log_df = parse_flaml_log(log_file)

    if log_df is None:
        return

    # 모델별 최적 손실
    if 'curr_learner' in log_df.columns and 'val_loss' in log_df.columns:
        best_per_model = log_df.groupby('curr_learner')['val_loss'].min()

        plt.figure(figsize=(10, 6))
        colors = plt.cm.viridis(range(0, 256, 256//len(best_per_model)))
        bars = plt.bar(best_per_model.index, 1 - best_per_model.values, color=colors)

        plt.xlabel('모델')
        plt.ylabel('정확도 (1 - loss)')
        plt.title('모델별 최적 성능')
        plt.xticks(rotation=45)

        # 값 표시
        for bar, val in zip(bars, 1 - best_per_model.values):
            plt.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.01,
                    f'{val:.4f}', ha='center', va='bottom')

        plt.tight_layout()
        plt.savefig('model_performance.png', dpi=100)
        plt.show()

plot_model_performance("flaml_training.log")

실시간 로그 모니터링

커스텀 콜백 사용

from flaml import AutoML
import time

class LoggingCallback:
    """학습 과정 실시간 출력"""

    def __init__(self):
        self.iteration = 0
        self.start_time = time.time()

    def __call__(self, result):
        self.iteration += 1
        elapsed = time.time() - self.start_time
        loss = result.get('val_loss', float('inf'))
        learner = result.get('learner', 'unknown')

        print(f"[{elapsed:6.1f}s] Iteration {self.iteration:3d} | "
              f"{learner:15s} | 손실: {loss:.4f} | 정확도: {1-loss:.4f}")

# 014 콜백 사용 (참고: FLAML 버전에 따라 지원 여부 다름)
# 014 automl.fit(..., cb=LoggingCallback())

Python 로깅 연동

logging 모듈 설정

import logging

# 014 로깅 설정
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('flaml_detailed.log'),
        logging.StreamHandler()
    ]
)

# 014 FLAML 로거 가져오기
flaml_logger = logging.getLogger('flaml.automl')
flaml_logger.setLevel(logging.INFO)

# 014 학습 실행
automl = AutoML()
automl.fit(
    X_train, y_train,
    task="classification",
    time_budget=30,
    verbose=1
)

로그 분석 리포트 생성

def generate_log_report(log_file):
    """로그 분석 리포트 생성"""
    log_df = parse_flaml_log(log_file)

    if log_df is None:
        print("로그를 파싱할 수 없습니다.")
        return

    print("="*60)
    print("FLAML 학습 로그 분석 리포트")
    print("="*60)

    # 기본 통계
    print(f"\n[기본 통계]")
    print(f"  총 반복 횟수: {len(log_df)}")
    if 'wall_clock_time' in log_df.columns:
        print(f"  총 학습 시간: {log_df['wall_clock_time'].max():.2f}초")

    # 모델별 통계
    if 'curr_learner' in log_df.columns:
        print(f"\n[모델별 탐색 횟수]")
        for learner, count in log_df['curr_learner'].value_counts().items():
            print(f"  {learner}: {count}회")

    # 성능 추이
    if 'best_loss' in log_df.columns:
        print(f"\n[성능 추이]")
        print(f"  초기 손실: {log_df['best_loss'].iloc[0]:.4f}")
        print(f"  최종 손실: {log_df['best_loss'].iloc[-1]:.4f}")
        print(f"  개선량: {log_df['best_loss'].iloc[0] - log_df['best_loss'].iloc[-1]:.4f}")

    print("="*60)

# 014 리포트 생성
generate_log_report("flaml_training.log")

정리

• verbose 파라미터로 로그 출력 수준을 조절합니다 (0, 1, 2).
• log_file_name으로 로그를 파일로 저장합니다.
• 로그는 JSON 형식으로 각 반복 정보를 기록합니다.
• 로그를 파싱하여 학습 곡선, 모델 비교 등을 시각화할 수 있습니다.
• Python logging 모듈과 연동하여 더 상세한 로그를 남길 수 있습니다.

다음 글 예고

다음 글에서는 FLAML 기초 총정리에 대해 알아보겠습니다. Part 1에서 배운 내용을 정리하고 핵심 포인트를 복습합니다.

---

FLAML AutoML 마스터 시리즈 #014