# VLA 모델 비교 분석 및 4000 Steps 설명

**작성일**: 2025-12-09 21:31  
**목적**: No Chunk 실험과 이전 모델들 비교, 과적합 여부 평가

---

## 📊 현재 학습 상태 (Epoch 5)

### 진행 상황
- **Epoch**: 5/10 (85% - 3385/4000)
- **경과 시간**: 5시간 32분
- **Val Loss**: **0.000532** ✅
- **Train Loss**: ~10^-5 수준

### Loss 추이
```
Epoch 1: val_loss = 0.00233
Epoch 2: val_loss = 0.00233 (동일)
Epoch 3: val_loss = 0.00167 (28% 개선 ↓)
Epoch 4: val_loss = ? (데이터 확인 필요)
Epoch 5: val_loss = 0.000532 (68% 개선 ↓↓)
```

**분석**: 계속 개선 중! Overfitting 징후 보이지 않음

---

## 🔢 4000 Steps가 나오는 이유

### 계산식
```
Steps per Epoch = (데이터셋 크기 / batch_size) / accumulate_grad_batches
```

### 실제 데이터
- **총 에피소드**: 500개 (`episode_20251*.h5`)
- **Train Split**: 0.8 (80%)
- **학습 에피소드**: 500 × 0.8 = 400개
- **Batch Size**: 1
- **Accumulate Grad Batches**: 8

### 계산
**가정**: 각 에피소드는 window_size=8로 인해 여러 샘플 생성

```
예상 샘플 수:
- 각 에피소드 평균 프레임: ~80-100개
- window_size=8로 슬라이딩하면: ~90 샘플/에피소드
- 총 샘플: 400 에피소드 × 90 = ~36,000 샘플

Steps per Epoch:
- 36,000 샘플 / (batch_size=1 × accumulate_grad_batches=8)
- = 36,000 / 8
- = 4,500 steps

실제 4000 steps:
- 데이터 filtering or padding으로 약간 감소
- 또는 에피소드당 평균 프레임이 ~70개
```

### 결론
**4000 steps = 전체 학습 데이터를 1번 완전히 순회**
- Batch size 1 × Accumulate 8 = Effective batch size 8
- 4000 steps × 8 = 32,000 샘플 처리

---

## 📋 모델 비교표

### 전체 실험 비교

| 모델 | fwd_pred_next_n | 데이터 | Val Loss | 방향 전략 | 학습 시간 | 상태 |
|:---|:---:|:---|---:|:---|:---|:---|
| **Case 2** (Lora) | 10 | left+right (500) | 0.027 | ❌학습 실패 | ~10 epochs | ❌ 모델 붕괴 |
| **Case 3** (Fixed) | 10 | left+right (500) | 0.059 | ❌학습 실패 | ~10 epochs | ❌ 방향 0% |
| **Case 4** (right_only) | 10 | right만 (250) | 0.016 | ✅ abs_action | ~10 epochs | ✅ 방향 100% |
| **Case 5** (aug_abs) | 10 | left+right(500→1000) | ? | ✅ abs_action | 미완료 | ⏳ 학습 필요 |
| **No Chunk** (현재) | **1** | **모든 데이터 (500)** | **0.000532** | **❓직접 학습** | 진행 중 | 🔄 Epoch 5/10 |

---

## 🎯 핵심 차이점

### 1. Action Chunking
**이전 모델들 (Case 2-5)**:
- `fwd_pred_next_n = 10`
- 한 번에 10개 액션 예측 (2초 미래 계획)
- **장점**: 안정적, 계획적
- **단점**: 학습 어려움, 복잡함

**No Chunk (현재)**:
- `fwd_pred_next_n = 1`
- 현재 상태에 대한 즉각 반응
- **장점**: 학습 쉬움 (Loss 0.0005 vs 0.016)
- **단점**: 떨림 가능, 장기 계획 불가

### 2. 데이터 사용
| 모델 | 에피소드 수 | 패턴 | Left/Right |
|:---|---:|:---|:---|
| Case 2-3 | 500 | left+right | 양쪽 |
| Case 4 | 250 | right만 | Right only |
| Case 5 | 1000 | Mirroring | 양쪽 증강 |
| No Chunk | **500** | **모든 20251*** | **양쪽 (원본)** |

**No Chunk의 특징**:
- `episode_pattern: "episode_20251*.h5"` 
- Case 4보다 2배 많은 데이터 (250 → 500)
- Left/Right 데이터 모두 포함

### 3. Loss 성능

```
Loss 비교 (낮을수록 좋음):
━━━━━━━━━━━━━━━━━━━━━━━━━━
Case 2 (LoRA):       0.027  ████████
Case 3 (Fixed):      0.059  ██████████████
Case 4 (right_only): 0.016  █████
No Chunk:            0.0005 █ (30배 낮음!)
```

**왜 No Chunk가 훨씬 낮을까?**
1. **태스크 단순화**: 10개 예측 → 1개 예측
2. **더 많은 데이터**: 250 → 500 에피소드
3. **학습 안정성**: Reactive policy가 예측하기 쉬움

---

## ⚠️ 과적합(Overfitting) 평가

### Train vs Val Loss 비교 필요

**현재 상황** (Epoch 5):
- Train Loss: ~10^-5 수준
- Val Loss: 0.000532
- **비율**: Val / Train ≈ 50 (과적합 의심!)

### 과적합 체크리스트

| 지표 | 상태 | 분석 |
|:---|:---:|:---|
| Val Loss 지속 감소 | ✅ | Epoch 1→5 계속 개선 |
| Train-Val Gap | ⚠️ | Train이 Val보다 100배 낮음 |
| Loss Spike | ✅ | Occasional spike 있음 (일반화) |
| 데이터 충분성 | ✅ | 500 에피소드 (충분) |

**결론**: 약간의 과적합 가능성 있으나, Val loss가 계속 개선 중이므로 심각하지 않음

### 평가 필요 사항

1. **Validation Curve 확인**
```bash
# CSV에서 val_loss 추출
grep "^[0-9]" metrics.csv | awk -F, '{print $1, $9}' | grep -v "^$"
```

2. **현재 체크포인트로 테스트**
   - Unseen 데이터로 평가
   - 실제 로봇 테스트
   - Left/Right 방향 정확도 확인

3. **Early Stopping 기준**
   - Val loss가 3 epoch 이상 개선 안 되면 중단
   - 현재: Epoch 3 (0.00167) → 5 (0.000532) 계속 개선 중

---

## 🔍 No Chunk의 의미

### 이론적 배경

**Action Chunking (RT-1, OpenVLA)**:
- 긴 시퀀스 예측으로 **일관된 행동** 학습
- Temporal coherence 유지

**Reactive Policy (No Chunk)**:
- 현재 관측만으로 즉각 반응
- **Markov Decision Process** 가정
- Behavior Cloning에서 더 쉬움

### 실용적 차이

| 상황 | Action Chunk (10) | No Chunk (1) |
|:---|:---|:---|
| 직선 주행 | 안정적 | 떨릴 수 있음 |
| 급커브 | 미리 계획 | 즉각 반응 |
| 장애물 회피 | 계획 필요 | 반응 충분 |
| 추론 속도 | 300ms/10액션 | 매 step 필요 |

### 예상 성능

**No Chunk의 장점**:
- ✅ 학습 훨씬 쉬움 (Loss 30배 낮음)
- ✅ 반응 속도 빠름
- ✅ 데이터 효율적

**No Chunk의 단점**:
- ❌ 떨림/진동 가능성
- ❌ 장기 계획 불가
- ❌ 궤적 일관성 낮을 수 있음

---

## 📊 Loss 상세 분석

### Epoch별 Val Loss

```python
# 예상 추이 (실제 데이터 기반)
Epoch 1: 0.00233   ━━━━━━━━━━━━
Epoch 2: 0.00233   ━━━━━━━━━━━━ (수렴 중)
Epoch 3: 0.00167   ━━━━━━━━━ (28% 개선)
Epoch 4: ~0.001    ━━━━━━ (추정)
Epoch 5: 0.000532  ━━━ (68% 개선)
Epoch 6-10: ?      (확인 필요)
```

### Overfitting 판단

**정상**:
- Val loss가 계속 감소
- Train loss도 함께 감소
- Gap이 일정 유지

**Overfitting**:
- Train loss만 감소
- Val loss 증가 또는 정체
- Gap이 계속 벌어짐

**현재 상황**: **정상 학습 중** (Val loss 지속 개선)

---

## 🎯 다음 단계

### 1. 과적합 평가 (즉시)
```bash
# Epoch별 val_loss 추출
grep "^[1-9]" runs/.../metrics.csv | awk -F, '{if ($9 != "") print "Epoch", $1, "val_loss:", $9}'

# 현재 체크포인트로 추론 테스트
export VLA_CHECKPOINT_PATH="<latest_checkpoint>"
$POETRY_PYTHON test_inference_stepbystep.py
```

### 2. 모델 비교 (학습 완료 후)
- No Chunk vs Case 4 (Action Chunk)
- 방향 정확도
- 추론 속도
- 안정성 (떨림 여부)

### 3. 실제 테스트
- TurtleBot4에서 실행
- Left/Right 명령 테스트
- 장기 주행 안정성 확인

---

## 💡 핵심 발견

1. **4000 Steps**: 전체 데이터셋 1 epoch = 500 에피소드를 window sliding으로 ~32,000 샘플 생성

2. **No Chunk가 Loss 30배 낮은 이유**:
   - 태스크 단순화 (10개 → 1개)
   - 더 많은 데이터 (250 → 500)
   - Reactive policy가 학습하기 쉬움

3. **과적합 가능성**: 약간 있으나 Val loss 계속 개선 중이므로 아직 정상

4. **실용성**: No Chunk가 학습은 쉽지만, 실제 성능(안정성)은 테스트 필요

---

**작성자**: AI Assistant  
**다음**: 과적합 평가 및 추론 테스트 진행