# Shape [10, 8, 64, 2048] 정확한 설명

## 📐 전체 구조

```python
shape: [10, 8, 64, 2048]
       │   │  │   └─── Feature Dimension (특징 차원)
       │   │  └─────── Token Dimension (토큰 개수)
       │   └────────── Frame/Temporal Dimension (프레임 개수)
       └────────────── Batch Dimension (배치/에피소드 개수)
```

---

## 🔍 각 차원 상세 설명

### **Dimension 0: `10` = Batch Size (에피소드 개수)**
- **의미**: 한 번에 처리한 episode 개수
- **코드 근거**:
  ```python
  # extract_and_compare_contexts.py Line 211
  images = load_sample_images(num_episodes=10)
  ```
- **실제**: 10개 에피소드 (left 5개 + right 5개)

---

### **Dimension 1: `8` = Window Size (시간 프레임)**
- **의미**: 각 에피소드에서 사용하는 연속된 이미지 프레임 수
- **이유**: Temporal context를 파악하기 위함
- **코드 근거**:
  ```python
  # extract_and_compare_contexts.py Lines 52-56
  for i in range(min(8, len(f['images']))):
      img = Image.fromarray(f['images'][i].astype(np.uint8))
      frames.append(transform(img))
  ```
- **설정 파일**:
  ```json
  // mobile_vla_lora_20251203.json
  "window_size": 8
  ```

**왜 8프레임인가?**
- 로봇이 "움직임의 맥락"을 이해하기 위함
- 정지 이미지 vs 움직이는 물체 구분 가능
- 속도와 방향 추정 가능

---

### **Dimension 2: `64` = Number of Tokens (토큰 개수)**
- **의미**: Kosmos-2 VLM이 한 이미지를 64개의 "의미 조각"으로 나눔
- **Vision Transformer 구조**:
  ```
  Image (224×224) 
    → Patch Embedding (14×14 patches)
    → Position Encoding
    → Transformer Processing
    → 64 tokens (압축된 표현)
  ```

**왜 64개인가?**
- Vision Transformer의 구조적 선택
- 224×224 이미지를 14×14 = 196개 패치로 나눔
- Transformer로 압축하여 64개 토큰으로 표현
- 각 토큰 = 이미지의 특정 "영역/의미"

**예시**:
```
Token 0-10:  박스 영역
Token 11-20: 배경
Token 21-30: 병 영역
Token 31-40: 바닥
...
```

---

### **Dimension 3: `2048` = Feature Dimension (특징 차원)**
- **의미**: 각 토큰을 표현하는 feature vector의 크기
- **Kosmos-2 구조**:
  ```
  Vision Features:  1024D
  Language Features: 1024D
  ─────────────────────────
  Total Context:    2048D (Concatenation)
  ```

**왜 2048차원인가?**
- Kosmos-2가 Vision + Language를 결합하여 표현
- 1024 (vision) + 1024 (language) = 2048
- 충분히 풍부한 정보 표현 가능

---

## 📊 실제 데이터 흐름

```python
# 1. 입력 이미지
Input: (10, 8, 3, 224, 224)
       │   │  │  │    └── Height
       │   │  │  └─────── Width  
       │   │  └────────── Channels (RGB)
       │   └───────────── Frames
       └───────────────── Episodes

# 2. VLM Forward Pass
VLM.encode_images(Input)

# 3. Context Vector 출력
Output: (10, 8, 64, 2048)
        │   │  │   └── Features per token
        │   │  └────── Tokens per frame
        │   └───────── Frames per episode
        └───────────── Episodes
```

---

## 🎯 실제 예시 (에피소드 1개)

```python
episode_1_context = context[0]  # Shape: (8, 64, 2048)

# Frame 0 (t=0초)
frame_0 = episode_1_context[0]  # Shape: (64, 2048)

# Token 5 (예: 박스 영역)
token_5_features = frame_0[5]   # Shape: (2048,)
# → 이 2048개 숫자가 "박스의 위치, 크기, 색상, 거리 등"을 표현
```

---

## 🔄 Action Head로 전달

```python
# Context: (10, 8, 64, 2048)
# ↓
# LSTM Decoder에 입력
# ↓
# Velocity 예측: (10, 2)
#   - linear_x: 전진 속도
#   - angular_z: 회전 속도
```

**핵심**: 
- 2048차원 feature가 충분히 "clear"해야 속도 예측 가능
- Case 1: Val Loss 0.013 달성 → Context가 충분히 informative!

---

## 📝 요약

| Dimension | 값 | 의미 | 이유 |
|:---|---:|:---|:---|
| **0** | `10` | Episodes | 한 번에 10개 에피소드 처리 |
| **1** | `8` | Frames | Window size (temporal context) |
| **2** | `64` | Tokens | 이미지를 64개 의미 조각으로 분해 |
| **3** | `2048` | Features | Vision(1024) + Language(1024) |

**전체 크기**:
- 10 × 8 × 64 × 2048 = **10,485,760** 개 숫자
- Float32: 10,485,760 × 4 bytes = **40 MB**

---

## ✅ 결론

**Shape [10, 8, 64, 2048]**은:
1. **10개 에피소드**를 
2. 각각 **8프레임씩** 보고
3. 각 프레임을 **64개 토큰**으로 나누고
4. 각 토큰을 **2048차원 벡터**로 표현한 것!

이것이 **Kosmos-2 VLM이 이미지를 "이해"한 결과**이며,  
이 context가 충분히 "clear"하기 때문에 LSTM이 **정확한 속도를 예측**할 수 있습니다.

---

**참조**: 
- 코드: `extract_and_compare_contexts.py`
- 모델: Kosmos-2 Vision-Language Model
- 논문: [Kosmos-2 Paper](https://arxiv.org/abs/2306.14824)