모델 학습과 튜닝

1하이퍼파라미터 최적화

하이퍼파라미터 튜닝은 모델 성능을 극대화하는 핵심 과정입니다. 학습률, 배치 크기, 레이어 수 등 수백 개의 조합 중 최적 값을 찾아야 합니다. 제조 AI에서는 도메인 특성상 데이터가 제한적이므로 효율적인 탐색 전략이 필수입니다.

Optuna는 베이지안 최적화를 사용하여 하이퍼파라미터 공간을 효율적으로 탐색합니다. Ray Tune은 분산 환경에서 대규모 실험을 병렬로 실행할 수 있습니다.

Grid Search

모든 조합을 시도하는 전수 탐색 방법입니다.

장점: 간단하고 확실
단점: 시간 소요가 매우 큼
사용: 파라미터가 2-3개일 때

Random Search

무작위로 조합을 샘플링합니다.

장점: Grid보다 효율적
단점: 최적값 보장 없음
사용: 초기 탐색 단계

Bayesian Optimization

이전 결과를 활용해 다음 시도를 결정합니다.

장점: 가장 효율적
단점: 구현 복잡도 높음
사용: 제한된 예산의 실험

Optuna 하이퍼파라미터 최적화 (수도코드)
# Optuna 기반 하이퍼파라미터 자동 최적화

# 1. 탐색할 하이퍼파라미터 정의
def objective(trial):
    config = {
        'num_layers': trial.suggest_int(2, 5),
        'hidden_dim': trial.suggest_categorical([128, 256, 512]),
        'learning_rate': trial.suggest_float(1e-5, 1e-2, log=True),
        'batch_size': trial.suggest_categorical([16, 32, 64]),
        'dropout': trial.suggest_float(0.1, 0.5)
    }

    # 모델 학습 및 검증
    model = DefectModel(config)
    trainer.fit(model, train_loader, val_loader)

    return val_accuracy  # 최대화할 지표

# 2. Study 생성 및 최적화 실행
study = optuna.create_study(
    direction='maximize',           # 정확도 최대화
    sampler=TPESampler(),           # 베이지안 최적화
    pruner=MedianPruner()           # 성능 낮으면 조기 종료
)

study.optimize(objective, n_trials=50)

# 3. 결과 확인
print(f"최적 정확도: {study.best_value}")
print(f"최적 파라미터: {study.best_params}")

Pruning으로 효율성 향상

Optuna의 Pruner는 성능이 낮은 시도를 조기에 중단합니다. MedianPruner는 중간값보다 낮은 성능의 실험을 자동으로 종료하여 탐색 시간을 50% 이상 단축합니다.

2분산 학습 전략

제조 데이터는 고해상도 이미지, 긴 시계열 등 크기가 큽니다. 단일 GPU로는 학습이 불가능하거나 너무 오래 걸리는 경우가 많습니다. 분산 학습(Distributed Training)은 여러 GPU나 서버에서 병렬로 학습하여 시간을 단축합니다.

PyTorch DDP (DistributedDataParallel)

PyTorch의 공식 분산 학습 방법으로, 각 GPU가 전체 모델의 복사본을 가지고 서로 다른 데이터 배치를 처리합니다. 그래디언트만 동기화하여 통신 오버헤드를 최소화합니다.

Data Parallel

배치를 GPU 수만큼 분할하여 병렬 처리. 가장 간단하지만 통신 병목 발생.

DDP (권장)

각 프로세스가 독립적으로 동작. 효율적인 그래디언트 동기화로 확장성 우수.

FSDP

모델 파라미터를 샤딩하여 메모리 효율 극대화. 초대형 모델에 적합.

DeepSpeed

Microsoft의 분산 학습 라이브러리. ZeRO 최적화로 메모리 사용량 1/8 감소.

PyTorch DDP 분산 학습 (수도코드)
# 분산 학습 핵심 개념

# 1. 분산 환경 초기화
setup_distributed(rank, world_size):
    init_process_group(backend='nccl')  # GPU 간 통신
    set_device(rank)                     # GPU 할당

# 2. 모델 래핑
model = model.to(gpu_rank)
model = DistributedDataParallel(model)

# 3. 데이터 분산 (각 GPU에 다른 배치)
sampler = DistributedSampler(dataset, num_replicas=world_size)
dataloader = DataLoader(dataset, sampler=sampler)

# 4. 학습 루프
for epoch in epochs:
    sampler.set_epoch(epoch)  # 셔플 재현성

    for batch in dataloader:
        with autocast():           # Mixed Precision (FP16)
            output = model(batch)
            loss = criterion(output, target)

        scaler.scale(loss).backward()
        scaler.step(optimizer)

    # 모든 GPU의 메트릭 집계
    all_reduce(metrics, op=SUM)
    metrics /= world_size

# 5. 체크포인트 저장 (Rank 0만)
if rank == 0:
    save(model.module.state_dict())

# 실행: torchrun --nproc_per_node=4 train.py

# Linear Scaling Rule: GPU 수에 비례하여 학습률 조정
# lr_new = lr_base × num_gpus

배치 크기와 학습률 조정

분산 학습 시 effective batch size가 증가하므로 학습률도 비례하여 조정해야 합니다. Linear Scaling Rule: lr_new = lr_base × num_gpus

3전이 학습과 파인튜닝

전이 학습(Transfer Learning)은 대규모 데이터셋으로 사전 학습된 모델을 제조 도메인에 맞게 조정하는 기법입니다.

Feature Extraction

사전 학습된 모델을 고정하고 마지막 레이어만 학습합니다.

데이터: 매우 적음 (100-1000개)
속도: 빠름
성능: 보통

Fine-tuning (권장)

사전 학습된 모델의 일부 레이어를 함께 학습합니다.

데이터: 적음 (1000-10000개)
속도: 보통
성능: 좋음

Full Training

전체 모델을 처음부터 학습합니다.

데이터: 많음 (100000개+)
속도: 느림
성능: 최고

전이 학습 전략 (수도코드)
# 전이 학습 3단계 전략

# 1단계: Feature Extraction (고정)
backbone = load_pretrained('efficientnet_b3')
freeze(backbone)  # 백본 가중치 고정
classifier = Linear(feature_dim → num_classes)
train(classifier, epochs=10, lr=1e-3)

# 2단계: Fine-tuning (일부 해동)
unfreeze(backbone.last_2_blocks)  # 마지막 2블록 해동
train(model, epochs=20, lr=1e-4)  # 낮은 학습률

# 3단계: Full Fine-tuning (전체 해동)
unfreeze(backbone)  # 전체 해동
train(model, epochs=30, lr=1e-5)  # 매우 낮은 학습률

# 핵심: 점진적으로 학습률을 낮추면서 더 많은 레이어 학습

4실험 관리와 모델 레지스트리

MLflow를 사용하여 실험을 체계적으로 관리하고, 모델 버전을 추적합니다.

MLflow 실험 관리 (수도코드)
# MLflow 실험 관리 흐름

# 1. 실험 시작
mlflow.set_experiment("defect_detection")

with mlflow.start_run():
    # 2. 하이퍼파라미터 로깅
    mlflow.log_params({
        "model": "efficientnet_b3",
        "lr": 1e-3,
        "batch_size": 32
    })

    # 3. 학습 메트릭 로깅
    for epoch in epochs:
        train_loss, val_acc = train_epoch()
        mlflow.log_metrics({
            "train_loss": train_loss,
            "val_acc": val_acc
        }, step=epoch)

    # 4. 모델 저장
    mlflow.pytorch.log_model(model, "model")

# 5. 모델 레지스트리 등록
mlflow.register_model(
    model_uri,
    name="defect_detector",
    tags={"stage": "staging"}
)

모델 레지스트리 Stage

None: 실험 단계 | Staging: 검증 테스트 중 | Production: 실제 배포 | Archived: 더 이상 사용 안함

5학습 모니터링

학습 과정을 실시간으로 모니터링하여 문제를 조기에 발견합니다.

학습 모니터링 체크리스트 (수도코드)
# 학습 중 모니터링 항목

# 1. Loss 추적
if loss > threshold or isnan(loss):
    alert("Loss 이상 감지")

# 2. 그래디언트 체크
grad_norm = compute_grad_norm(model)
if grad_norm > 100:  # Gradient Explosion
    alert("그래디언트 폭발")
if grad_norm < 1e-7:  # Gradient Vanishing
    alert("그래디언트 소실")

# 3. GPU 모니터링
if gpu_memory_usage > 90%:
    alert("메모리 부족")
if gpu_utilization < 50%:
    alert("GPU 활용률 낮음 - 데이터 로딩 병목")

# 4. 검증 메트릭 추적
if val_loss increasing for 5 epochs:
    early_stop()  # 과적합 방지

# 5. 체크포인트 저장
if val_acc > best_val_acc:
    save_checkpoint(model, "best_model.pt")