2nd/10_Wiki/Topics/AI_and_ML/Autonomous Vehicles.md

---
id: wiki-2026-0508-autonomous-vehicles
title: Autonomous Vehicles
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [자율주행, AV, self-driving, Tesla FSD, Waymo, robotaxi, SAE levels, end-to-end driving]
duplicate_of: none
source_trust_level: A
confidence_score: 0.92
verification_status: applied
tags: [autonomous-vehicles, robotics, perception, lidar, end-to-end, fsd, waymo, sae-levels, safety-critical]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: C++ / Python
  framework: ROS / Apollo / Autoware / NVIDIA DRIVE
---

# Autonomous Vehicles

## 📌 한 줄 통찰
> **"매 wheels 의 movable computer"**. 매 perception + localization + prediction + planning + control 의 5-stack. 매 modern: 매 end-to-end neural net 의 rule-based 의 superseed. 매 Tesla FSD v12 / Waymo / Mobileye / NVIDIA DRIVE 의 commercialization.

## 📖 핵심

### 매 SAE level
| Level | Description | 예 |
|---|---|---|
| 0 | No automation | manual |
| 1 | Driver assist (cruise) | adaptive cruise |
| 2 | Partial (steering + speed) | Tesla AP, GM Super Cruise |
| 3 | Conditional (eyes off in ODD) | Mercedes Drive Pilot, Honda Sensing |
| 4 | High (no driver in ODD) | Waymo, Cruise (suspended), Zoox |
| 5 | Full (any condition) | 매 not yet |

→ ODD = Operational Design Domain.

### 매 stack

#### 1. Sensors
- **Camera**: 매 cheap, 매 rich. Tesla 의 vision-only.
- **Radar**: 매 long-range, 매 weather-robust.
- **LiDAR**: 매 3D, 매 expensive. Waymo / Cruise 사용.
- **Ultrasonic**: 매 short-range parking.
- **IMU + GPS**: 매 ego-motion.
- **HD Map**: 매 lane / sign / topology.

#### 2. Perception
- 매 detection (3D bbox).
- 매 segmentation (BEV, lane).
- 매 tracking (multi-object).
- 매 sensor fusion (Kalman / DL).

#### 3. Localization
- 매 GPS + IMU + map matching.
- 매 SLAM (LiDAR / visual).
- 매 cm-level accuracy required.

#### 4. Prediction
- 매 surrounding agent 의 trajectory.
- 매 multimodal (multiple intent).
- 매 socially-aware.

#### 5. Planning
- 매 behavior (lane change, merge).
- 매 trajectory (geometry + time).
- 매 motion (control input).

#### 6. Control
- 매 steering + throttle + brake.
- 매 PID / MPC / NN.

### 매 paradigm

#### Modular (전통)
- 매 stack 의 separate.
- 매 explainable.
- 매 error 의 propagate.

#### End-to-End (Tesla FSD v12, Wayve)
- 매 video → 매 control.
- 매 single NN.
- ✅ 매 better edge case.
- ❌ 매 black box, 매 verification 어려움.

#### Hybrid (Waymo)
- 매 modular + 매 NN per stage.
- 매 verifiable.

### 매 challenge
1. **Long tail**: 매 rare event (animal, crash, construction).
2. **Adversarial weather** (snow, fog).
3. **Verification**: 매 billion mile 의 simulation.
4. **Liability**: 매 maker / driver / software.
5. **Trolley problem**: 매 ethical edge.
6. **HD map maintenance**.
7. **Edge case generalization**.

### Players (2026)
- **Tesla**: FSD v12, vision-only, end-to-end.
- **Waymo**: robotaxi (SF, LA, Phoenix).
- **Mobileye**: ADAS supplier.
- **Cruise**: suspended (2024 incident).
- **Zoox** (Amazon): purpose-built.
- **NVIDIA DRIVE**: platform (BYD, Jaguar, Mercedes).
- **Wayve / Comma**: end-to-end.

### 매 simulation
- **CARLA**: open-source.
- **NVIDIA DRIVE Sim** / **DriveWorks**.
- **Waymo Carcraft**.
- **Tesla simulation**: 매 HW + 매 photoreal.

## 💻 패턴

### Sensor fusion (Kalman)
```python
import numpy as np

class KalmanFilter:
    def __init__(self, F, H, Q, R, x0, P0):
        self.F, self.H, self.Q, self.R = F, H, Q, R  # transition, obs, proc noise, meas noise
        self.x, self.P = x0, P0
    
    def predict(self):
        self.x = self.F @ self.x
        self.P = self.F @ self.P @ self.F.T + self.Q
    
    def update(self, z):
        y = z - self.H @ self.x
        S = self.H @ self.P @ self.H.T + self.R
        K = self.P @ self.H.T @ np.linalg.inv(S)
        self.x = self.x + K @ y
        self.P = (np.eye(len(self.x)) - K @ self.H) @ self.P
```

### 3D detection (PyTorch + LiDAR)
```python
# 매 PointPillars / VoxelNet / CenterPoint style
import torch
class PointPillars(torch.nn.Module):
    def forward(self, points):
        # 매 1. voxelize
        pillars = self.voxelize(points, voxel_size=[0.16, 0.16, 4.0])
        # 매 2. PointNet 의 per-pillar feature
        features = self.pointnet(pillars)
        # 매 3. BEV pseudo-image
        bev = self.scatter(features)
        # 매 4. 2D backbone + detection head
        return self.detection_head(self.backbone(bev))
```

### Trajectory prediction (Transformer)
```python
class TrajectoryPredictor(nn.Module):
    """매 surrounding agent 의 multimodal trajectory."""
    def __init__(self):
        self.encoder = TransformerEncoder()
        self.decoder = MultimodalHead(n_modes=6)
    
    def forward(self, agent_history, map_features):
        ctx = self.encoder(agent_history, map_features)
        # 매 6 mode 의 trajectory + 매 confidence
        return self.decoder(ctx)  # 매 (B, 6, T, 2) + (B, 6)
```

### Path planner (RRT*)
```python
def rrt_star(start, goal, obstacles, max_iter=1000):
    nodes = [start]
    parent = {0: None}
    for _ in range(max_iter):
        rand = sample_random()
        nearest = min(range(len(nodes)), key=lambda i: dist(nodes[i], rand))
        new = steer(nodes[nearest], rand, step=1.0)
        if not collides(new, obstacles):
            nodes.append(new)
            parent[len(nodes)-1] = nearest
            if dist(new, goal) < 0.5:
                return reconstruct_path(nodes, parent, len(nodes)-1)
    return None
```

### Behavior planner (FSM)
```python
class BehaviorPlanner:
    def __init__(self):
        self.state = 'KEEP_LANE'
    
    def step(self, scene):
        if self.state == 'KEEP_LANE':
            if scene.front_too_slow and scene.left_lane_clear:
                self.state = 'PREP_LANE_CHANGE_LEFT'
        elif self.state == 'PREP_LANE_CHANGE_LEFT':
            if scene.left_gap_safe:
                self.state = 'LANE_CHANGE_LEFT'
            elif scene.front_clear:
                self.state = 'KEEP_LANE'
        # ...
        return self.state
```

### MPC (Model Predictive Control)
```python
import cvxpy as cp

def mpc_step(x_current, x_ref, horizon=10, dt=0.1):
    x = cp.Variable((horizon+1, 4))  # [x, y, v, ψ]
    u = cp.Variable((horizon, 2))     # [a, δ]
    
    cost = 0
    constraints = [x[0] == x_current]
    for t in range(horizon):
        cost += cp.sum_squares(x[t+1] - x_ref[t+1]) + 0.1 * cp.sum_squares(u[t])
        constraints += [x[t+1] == bicycle_model(x[t], u[t], dt)]
        constraints += [cp.abs(u[t, 1]) <= 0.5]  # steering limit
    
    cp.Problem(cp.Minimize(cost), constraints).solve()
    return u[0].value  # 매 first control 의 apply
```

## 🤔 결정 기준
| 상황 | Approach |
|---|---|
| ADAS L2 | Camera + radar + rule-based |
| Robotaxi | Sensor fusion + HD map (Waymo) |
| Mass market | Vision-only end-to-end (Tesla) |
| Truck (highway) | LiDAR + radar (long-range) |
| Simulation | CARLA + photoreal |
| Ethics edge case | Hardcoded principle + transparent log |

**기본값**: Modular for safety-critical. End-to-end for scale.

## 🔗 Graph
- 부모: [[Robotics]] · [[Computer Vision|Computer-Vision]]
- 변형: [[Tesla-FSD]] · [[Waymo]]
- 응용: [[SLAM]] · [[End-to-End-Driving]]
- Adjacent: [[Reinforcement-Learning]] · [[AI Safety]]

## 🤖 LLM 활용
**언제**: 매 AV system architecture review. 매 ADAS feature design. 매 simulation scenario. 매 sensor fusion debug.
**언제 X**: 매 specific safety certification (ISO 26262 / SOTIF). 매 medical-grade real-time.

## ❌ 안티패턴
- **Single sensor**: 매 weather / occlusion 의 fail.
- **HD map only** (no perception): 매 stale.
- **No sim 의 verify**: 매 production 의 first encounter.
- **Edge case 의 ignore**: 매 long tail 의 fatal.
- **End-to-end 의 verify 의 X**: 매 unexplained behavior.
- **No graceful degradation**: 매 sensor fail = 매 crash.

## 🧪 검증 / 중복
- Verified (SAE J3016, Waymo / Tesla papers, ISO 26262).
- 신뢰도 A.
- Related: [[Tesla-FSD]] · [[Waymo]] · [[SLAM]] · [[End-to-End-Driving]] · [[AI Safety]].

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — SAE level + stack + 매 Kalman / PointPillars / RRT / MPC code |