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

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

id	title	category	status	canonical_id	aliases	duplicate_of	source_trust_level	confidence_score	verification_status	tags	raw_sources	last_reinforced	github_commit	tech_stack
wiki-2026-0508-autonomous-vehicles	Autonomous Vehicles	10_Wiki/Topics	verified	self	자율주행 AV self-driving Tesla FSD Waymo robotaxi SAE levels end-to-end driving	none	A	0.92	applied	autonomous-vehicles robotics perception lidar end-to-end fsd waymo sae-levels safety-critical		2026-05-10	pending	language framework C++ / Python 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)

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)

# 매 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)

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*)

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)

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)

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
• 변형: 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