자율주행/로보틱스 기술 스택 완전 정복: C++, ROS2, CUDA, TensorRT부터 VLM/VLA, 시뮬레이션까지

• 1. 개요
• 2. Modern C++ for Robotics (C++17/20/23)
  • 2.1 왜 C++인가
  • 2.2 표준별 핵심 기능
    • C++17 (로보틱스 베이스라인)
    • C++20 (현재 로보틱스 표준)
    • C++23 (로보틱스 도입 중)
  • 2.3 실시간 프로그래밍 주의사항
  • 2.4 학습 자료
• 3. ROS / ROS2 (Robot Operating System)
  • 3.1 ROS2란
  • 3.2 ROS1 vs ROS2
  • 3.3 DDS 미들웨어 계층
  • 3.4 핵심 개념
  • 3.5 학습 자료
• 4. 자율주행 Computer Vision
  • 4.1 핵심 패러다임: BEV (Bird's-Eye-View) 표현
  • 4.2 인식 파이프라인
  • 4.3 End-to-End 인식-계획 통합
  • 4.4 학습 자료
• 5. VLM/VLA 모델 (Vision-Language-Action)
  • 5.1 VLA란
  • 5.2 주요 모델 연대기
  • 5.3 핵심 개념
  • 5.4 학습 자료
• 6. CUDA와 병렬 프로그래밍
  • 6.1 왜 GPU인가
  • 6.2 CUDA 프로그래밍 모델
  • 6.3 자율주행 CUDA 활용
  • 6.4 NVIDIA 자율주행 플랫폼
  • 6.5 생태계 라이브러리
  • 6.6 학습 자료
• 7. TensorRT
  • 7.1 TensorRT란
  • 7.2 핵심 최적화 기법
    • Layer/Kernel Fusion
    • Precision Calibration
    • 배포 워크플로
  • 7.3 통합 옵션
  • 7.4 학습 자료
• 8. 모델 최적화 (양자화, 프루닝, 증류)
  • 8.1 왜 필요한가
  • 8.2 양자화 (Quantization)
  • 8.3 프루닝 (Pruning)
  • 8.4 지식 증류 (Knowledge Distillation)
  • 8.5 업계 표준 파이프라인 (2025)
  • 8.6 도구
• 9. 센서 퓨전 (GPS, IMU, Camera, LiDAR)
  • 9.1 왜 퓨전인가
  • 9.2 퓨전 아키텍처
  • 9.3 고전 상태 추정
    • 칼만 필터 (KF)
  • 9.4 센서 캘리브레이션
  • 9.5 학습 자료
• 10. SIL/HIL 테스팅
  • 10.1 왜 필요한가
  • 10.2 SIL (Software-in-the-Loop)
  • 10.3 HIL (Hardware-in-the-Loop)
  • 10.4 V-모델 테스트 피라미드
  • 10.5 업계 도구
• 11. 시뮬레이션 소프트웨어
  • 11.1 주요 시뮬레이터 비교
  • 11.2 CARLA (오픈소스, Unreal Engine)
  • 11.3 NVIDIA Isaac Sim
  • 11.4 학습 자료
• 12. 자율주행 풀 스택
  • 12.1 모듈식 스택 아키텍처
  • 12.2 End-to-End vs 모듈식
  • 12.3 오픈소스 스택
• 13. VR/AR와 디지털 트윈
  • 13.1 활용 분야
  • 13.2 핵심 플랫폼
• 14. 클라우드 기술
  • 14.1 왜 클라우드인가
  • 14.2 데이터 파이프라인
  • 14.3 핵심 기술
  • 14.4 OTA (Over-the-Air) 업데이트
  • 14.5 데이터 플라이휠
• 15. 학습 로드맵
  • 15.1 기초 (1-3개월)
  • 15.2 중급 (3-6개월)
  • 15.3 고급 (6-12개월)
• 16. References
  • 공식 문서
  • 핵심 논문
  • GitHub 저장소
  • 블로그 및 해설

1. 개요

자율주행과 로보틱스 시스템은 단일 기술이 아닌 수십 가지 기술의 융합체다. 센서로부터 원시 데이터를 받아 환경을 인식하고, 경로를 계획하고, 차량을 제어하는 전체 파이프라인에는 C++, GPU 프로그래밍, 딥러닝, 센서 퓨전, 시뮬레이션, 클라우드 인프라가 모두 관여한다.

이 포스트는 자율주행/로보틱스 엔지니어가 알아야 할 13개 핵심 기술 영역을 실전 관점에서 정리한다.

┌────────────────────────────────────────────────────────────────┐
│                    자율주행 기술 스택 전체 구조                    │
│                                                                │
│  ┌──────────┐  ┌───────────┐  ┌───────────┐  ┌──────────────┐ │
│  │ 센서 계층 │  │ 인식 계층  │  │ 판단 계층  │  │  제어 계층    │ │
│  │ GPS/IMU  │→│ CV/DL     │→│ Planning  │→│ Control      │ │
│  │ Camera   │  │ 센서 퓨전  │  │ Prediction│  │ CAN/Ethernet │ │
│  │ LiDAR    │  │ VLM/VLA   │  │           │  │              │ │
│  └──────────┘  └───────────┘  └───────────┘  └──────────────┘ │
│                                                                │
│  ┌──────────────────────────────────────────────────────────┐  │
│  │ 인프라 계층: C++ | ROS2 | CUDA | TensorRT | Cloud/MLOps │  │
│  └──────────────────────────────────────────────────────────┘  │
│                                                                │
│  ┌──────────────────────────────────────────────────────────┐  │
│  │ 검증 계층: SIL/HIL | Simulation(CARLA/Isaac) | VR/AR    │  │
│  └──────────────────────────────────────────────────────────┘  │
└────────────────────────────────────────────────────────────────┘

2. Modern C++ for Robotics (C++17/20/23)

2.1 왜 C++인가

로보틱스는 결정론적 실행, 제로 오버헤드 추상화, 하드웨어 직접 접근을 요구한다. Modern C++는 이 세 가지를 모두 제공하면서도 코드 안전성과 표현력을 대폭 향상시킨다. ROS2 노드부터 CUDA 커널, 실시간 제어 루프까지 모든 성능 핵심 코드는 C++로 작성된다.

2.2 표준별 핵심 기능

C++17 (로보틱스 베이스라인)

C++20 (현재 로보틱스 표준)

// Concepts: 타입 안전한 센서 인터페이스
template<typename T>
concept Sensor = requires(T s) {
    { s.read() } -> std::convertible_to<SensorData>;
    { s.calibrate() } -> std::same_as<bool>;
};

// Ranges: 센서 데이터 파이프라인
auto obstacles = pointCloud
    | views::filter(isAboveGround)
    | views::transform(toWorldFrame)
    | views::take(maxObstacles);

// Coroutines: RTOS 오버헤드 없는 협력적 멀티태스킹
// co_await, co_yield로 비동기 I/O 처리

• Concepts: 템플릿 파라미터 제약 → 컴파일 타임 타입 안전성
• Ranges: 조합 가능한 lazy 데이터 변환
• Coroutines: 임베디드 플랫폼의 비동기 I/O
• std::jthread: 협력적 취소가 가능한 스레드

C++23 (로보틱스 도입 중)

• std::expected<T, E>: 예외 없는 에러 처리 (실시간 코드에서 예외는 금지)
• std::mdspan: 이미지/텐서 데이터의 다차원 배열 뷰 (복사 없이)
• std::print: 타입 안전한 포맷 출력

2.3 실시간 프로그래밍 주의사항

✗ Hot path에서 동적 메모리 할당 → ✓ std::pmr 할당자 또는 사전 할당 풀
✗ 실시간 제어 루프에서 예외 → ✓ std::expected 또는 에러 코드
✗ 뮤텍스 기반 통신 → ✓ std::atomic, lock-free 자료구조
✗ 기본 스케줄링 → ✓ SCHED_FIFO / SCHED_RR (POSIX)

2.4 학습 자료

• Programming with C++20 — Andreas Fertig
• Modern C++ Blog

3. ROS / ROS2 (Robot Operating System)

3.1 ROS2란

ROS2는 로봇 애플리케이션 구축을 위한 오픈소스 미들웨어다. ROS1을 완전히 재작성하여 실시간, 다중 로봇, 프로덕션급 배포를 지원한다. 최신 LTS 릴리스는 ROS2 Jazzy Jalisco (2024.05)이다.

3.2 ROS1 vs ROS2

3.3 DDS 미들웨어 계층

ROS2는 Data Distribution Service (DDS) 표준을 통해 통신한다.

핵심 QoS 프로파일: Reliability(Best-Effort vs Reliable), Durability(Volatile vs Transient-Local), History Depth, Deadline, Liveliness

3.4 핵심 개념

3.5 학습 자료

• ROS2 Jazzy 공식 문서
• ROS on DDS 설계 문서

4. 자율주행 Computer Vision

4.1 핵심 패러다임: BEV (Bird's-Eye-View) 표현

2024-2026년의 지배적 패러다임은 다중 카메라 뷰를 통합 BEV 특징 공간으로 투영하는 것이다.

Front Camera ──┐
Left Camera  ──┤
Right Camera ──┼──→ [BEV Feature Space] ──→ 3D Detection
Rear Camera  ──┤                            Lane Detection
Side Cameras ──┘                            Occupancy Prediction

4.2 인식 파이프라인

4.3 End-to-End 인식-계획 통합

인식 진화 경로:
CNN (2011-2016) → RNN+GAN (2016-2018) → BEV (2018-2020)
→ Transformer+BEV (2020-현재) → Occupancy (2022-현재) → End-to-End VLA (2024-현재)

• UniAD (CVPR 2023 Best Paper): 인식+예측+계획을 하나의 네트워크에서 수행
• VAD: 벡터화된 장면 표현 기반 End-to-End 주행
• DriveTransformer (ICLR 2025): 효율적 병렬 End-to-End 아키텍처

4.4 학습 자료

• BEVDet to BEVFormer (Autoware)
• OpenDriveLab/UniAD
• OpenDriveLab/End-to-end-Autonomous-Driving

5. VLM/VLA 모델 (Vision-Language-Action)

5.1 VLA란

Vision-Language-Action (VLA) 모델은 시각 입력(카메라 이미지)과 언어 명령을 받아 로봇 행동을 직접 출력하는 Foundation Model이다. 인터넷 스케일의 Vision-Language 사전학습과 로봇 제어를 연결하는 가교 역할을 한다.

5.2 주요 모델 연대기

5.3 핵심 개념

행동 출력 방식 비교:

RT-2 방식 (Action Tokenization):
  "move arm" → LLM → [토큰256] [토큰128] [토큰064] → 이산 행동

pi0 방식 (Flow Matching):
  "move arm" → VLM → Flow Expert → 연속적 벡터 필드 → 부드러운 행동

• Action Tokenization: 연속 행동을 어휘 토큰으로 이산화 (RT-2)
• Flow Matching: 학습된 벡터 필드로 연속 행동 생성 (pi0)
• Cross-Embodiment Transfer: 다중 로봇 타입으로 학습 → 일반화
• Open X-Embodiment: 21개+ 기관, 1M+ 에피소드 협력 데이터셋

5.4 학습 자료

• RT-2 프로젝트 페이지
• VLA Survey: Review Towards Real-World Applications
• openvla/openvla
• octo-models/octo

6. CUDA와 병렬 프로그래밍

6.1 왜 GPU인가

자율주행 차량은 다중 카메라 스트림, LiDAR 포인트 클라우드, 레이더 신호를 동시 처리하면서 여러 신경망을 100ms 이내에 실행해야 한다. CPU만으로는 불가능하다.

6.2 CUDA 프로그래밍 모델

┌─────────────────────────────────────────────┐
│              CUDA 메모리 계층                  │
│                                              │
│  레지스터 (스레드당)                            │
│    ↓                                         │
│  공유 메모리 (블록당, ~48-164KB)               │
│    ↓                                         │
│  L2 캐시                                     │
│    ↓                                         │
│  글로벌 메모리 (VRAM)                          │
│                                              │
│  스레드 → 워프(32개) → 블록(최대1024) → 그리드   │
└─────────────────────────────────────────────┘

6.3 자율주행 CUDA 활용

6.4 NVIDIA 자율주행 플랫폼

6.5 생태계 라이브러리

cuDNN(딥러닝), cuBLAS(선형대수), Thrust(병렬 STL), CUB(블록/디바이스 프리미티브), NCCL(다중 GPU 통신), cuPCL(포인트 클라우드)

6.6 학습 자료

• NVIDIA CUDA Programming Guide
• How DRIVE AGX, CUDA, and TensorRT Achieve Fast Perception

7. TensorRT

7.1 TensorRT란

NVIDIA의 고성능 딥러닝 추론 SDK다. PyTorch/TensorFlow/ONNX 모델을 그래프 최적화, 커널 자동 튜닝, 정밀도 캘리브레이션, 메모리 관리를 통해 최적화한다. 일반적으로 2~10배 속도 향상을 달성한다.

7.2 핵심 최적화 기법

Layer/Kernel Fusion

최적화 전: Conv → BatchNorm → ReLU (3개 커널 실행)
최적화 후: Conv+BN+ReLU (1개 커널 실행)

효과: 커널 실행 오버헤드 최대 80% 감소
      메모리 대역폭 최대 50% 감소
      처리량 ~30% 향상

Precision Calibration

PTQ (Post-Training Quantization): 재학습 불필요, 캘리브레이션 데이터만으로 양자화 QAT (Quantization-Aware Training): 학습 중 양자화 시뮬레이션 → 더 높은 정확도

배포 워크플로

PyTorch Model
  → ONNX Export (torch.onnx.export)
  → TensorRT Builder (trtexec 또는 Python API)
    → 그래프 최적화 + 레이어 퓨전
    → 정밀도 캘리브레이션 (INT8/FP8)
    → 커널 자동 튜닝
  → 직렬화된 엔진 (.engine 파일)
  → TensorRT Runtime (추론)

7.3 통합 옵션

7.4 학습 자료

• NVIDIA TensorRT Documentation
• TensorRT Export for YOLO Models (Ultralytics)

8. 모델 최적화 (양자화, 프루닝, 증류)

8.1 왜 필요한가

BEVFormer 모델은 FP32에서 50+ TFLOPS가 필요하다 — 차량 내 SoC에서는 불가능하다. 모델 최적화로 4~16배 감소시키면서 원래 정확도의 95% 이상을 유지할 수 있다.

8.2 양자화 (Quantization)

가중치와 활성화의 수치 정밀도를 낮추는 기법.

정밀도 수준:

8.3 프루닝 (Pruning)

불필요한 가중치/뉴런/채널을 제거하는 기법.

8.4 지식 증류 (Knowledge Distillation)

큰 "교사" 모델의 지식을 작은 "학생" 모델로 전이한다.

• Logit 증류: 학생이 교사의 출력 확률 분포를 모방
• Feature 증류: 학생이 교사의 중간 표현을 모방
• QAD: 양자화 에러를 처리하면서 교사를 모방

8.5 업계 표준 파이프라인 (2025)

Large Teacher (FP32)
  → Knowledge Distillation → Smaller Student
  → Structured Pruning → 채널/헤드 제거
  → QAT Fine-tuning → INT8/FP8
  → TensorRT Export → 퓨전·최적화 엔진

8.6 도구

• NVIDIA Model Optimizer (ModelOpt): 양자화, 프루닝, 증류, 희소성 통합 API
• PyTorch: torch.quantization, torch.ao.quantization
• Hugging Face Optimum: 트랜스포머 모델 최적화

9. 센서 퓨전 (GPS, IMU, Camera, LiDAR)

9.1 왜 퓨전인가

퓨전은 각 센서의 약점을 상호 보완한다.

9.2 퓨전 아키텍처

2025년 지배적 트렌드: Unified BEV + Token-Level Cross-Modal Attention

9.3 고전 상태 추정

칼만 필터 (KF)

Predict (예측):  x̂ₖ|ₖ₋₁ = F·x̂ₖ₋₁ + B·uₖ
                 Pₖ|ₖ₋₁ = F·Pₖ₋₁·Fᵀ + Q

Update (보정):   Kₖ = Pₖ|ₖ₋₁·Hᵀ·(H·Pₖ|ₖ₋₁·Hᵀ + R)⁻¹
                 x̂ₖ = x̂ₖ|ₖ₋₁ + Kₖ·(zₖ - H·x̂ₖ|ₖ₋₁)

상태 벡터 (EKF 일반적): [x, y, z, roll, pitch, yaw, vx, vy, vz, ax, ay, az]

9.4 센서 캘리브레이션

9.5 학습 자료

• Multi-Sensor Fusion in AD Survey (MDPI)
• Extended-Kalman-Filter-GPS_IMU (GitHub)

10. SIL/HIL 테스팅

10.1 왜 필요한가

물리적 도로 테스트로 안전성을 통계적으로 증명하려면 110억 마일 주행이 필요하다 (Waymo 추정). SIL/HIL 시뮬레이션은 하루에 수백만 마일을 시뮬레이션할 수 있다.

10.2 SIL (Software-in-the-Loop)

┌──────────────────────────────────────────────────┐
│                    SIL 환경                        │
│                                                   │
│  [인식 알고리즘] ←→ [센서 시뮬레이션]               │
│  [계획 알고리즘] ←→ [시나리오 엔진]                 │
│  [제어 알고리즘] ←→ [차량 역학 모델]                │
│                                                   │
│  실행 환경: Host PC (x86)                          │
│  물리 하드웨어: 없음                                │
│  반복 속도: 초~분                                   │
│  CI/CD 통합: 가능 (클라우드 병렬화)                  │
└──────────────────────────────────────────────────┘

장점: 하드웨어 비용 없음, 완전 재현 가능, CI/CD 통합, 클러스터 병렬화

10.3 HIL (Hardware-in-the-Loop)

┌──────────────────────────────────────────────────┐
│                    HIL 환경                        │
│                                                   │
│  [실제 ECU (DUT)] ←→ [HIL 시뮬레이터]              │
│                       ├ 차량 역학 모델              │
│                       ├ 센서 신호 주입 (HDMI/ETH)  │
│                       ├ 버스 시뮬레이션 (CAN/ETH)   │
│                       └ 고장 주입                   │
│                                                   │
│  실행 환경: 실제 타겟 하드웨어 (Orin, EyeQ 등)      │
│  실시간: 하드웨어 클록 레이트                        │
│  ISO 26262: 기능 안전 인증에 필수                    │
└──────────────────────────────────────────────────┘

10.4 V-모델 테스트 피라미드

MIL (Model-in-the-Loop)     — MATLAB/Simulink 프로토타이핑
  → SIL                      — Host PC + 시뮬레이션 환경
    → PIL (Processor-in-the-Loop) — 타겟 프로세서 컴파일, Host 실행
      → HIL                  — 타겟 ECU + 시뮬레이션 환경
        → VIL (Vehicle-in-the-Loop) — 실차 + 시나리오 주입
          → Road Testing     — 실차 + 실환경

10.5 업계 도구

11. 시뮬레이션 소프트웨어

11.1 주요 시뮬레이터 비교

*LGSVL은 LG에 의해 중단됨

11.2 CARLA (오픈소스, Unreal Engine)

# CARLA Docker 실행
docker pull carlasim/carla:0.9.15
docker run --privileged --gpus all --net=host \
    carlasim/carla:0.9.15 /bin/bash ./CarlaUE4.sh

# Python API로 시나리오 제어
pip install carla

import carla

client = carla.Client('localhost', 2000)
world = client.get_world()

# 차량 스폰
blueprint = world.get_blueprint_library().find('vehicle.tesla.model3')
spawn_point = world.get_map().get_spawn_points()[0]
vehicle = world.spawn_actor(blueprint, spawn_point)

# 카메라 센서 부착
camera_bp = world.get_blueprint_library().find('sensor.camera.rgb')
camera = world.spawn_actor(camera_bp, carla.Transform(), attach_to=vehicle)

• GitHub: carla-simulator/carla (10K+ stars)
• OpenDRIVE 맵 포맷, ROS/ROS2 브릿지

11.3 NVIDIA Isaac Sim

• Omniverse(USD) 기반, RTX 렌더러로 포토리얼리스틱 RGB, 깊이, 세그멘테이션 마스크
• PhysX GPU 가속 물리 엔진
• NuRec 신경 렌더링으로 Sim-to-Real 갭 최소화
• Isaac Lab(RL 학습), Replicator(합성 데이터), Cosmos(생성 AI 환경)

11.4 학습 자료

• CARLA 공식 문서
• NVIDIA Isaac Sim 문서

12. 자율주행 풀 스택

12.1 모듈식 스택 아키텍처

┌─────────────────────────────────────────────────────────────────┐
│                     자율주행 풀 스택                               │
│                                                                  │
│  1. Sensing         센서 드라이버, 시간 동기화, 로깅               │
│       ↓                                                          │
│  2. Localization    HD Map 매칭, V-SLAM, LiDAR SLAM, GNSS/IMU   │
│       ↓              → 6-DOF 차량 자세 (100+ Hz)                  │
│  3. Perception      3D 검출, 추적, 시맨틱 세그멘테이션, Occupancy  │
│       ↓              → 3D 바운딩 박스, 트랙 ID, 시맨틱 맵          │
│  4. Prediction      에이전트 미래 궤적 예측 (3-8초)                │
│       ↓              → 에이전트별 다중 모드 궤적                    │
│  5. Planning        경로 계획, 행동 계획, 모션 계획                │
│       ↓              → 궤적 (자세 + 속도 시퀀스)                   │
│  6. Control         횡방향(조향) + 종방향(가감속) 제어              │
│       ↓              → CAN 명령 (steer-by-wire, brake-by-wire)   │
└─────────────────────────────────────────────────────────────────┘

12.2 End-to-End vs 모듈식

12.3 오픈소스 스택

• autowarefoundation/autoware
• ApolloAuto/apollo

13. VR/AR와 디지털 트윈

13.1 활용 분야

13.2 핵심 플랫폼

• NVIDIA Omniverse: USD 기반, 실시간 렌더링, 물리 시뮬, 다중 사용자 협업
• Unity + ROS: Unity Robotics Hub로 ROS-Unity 통합
• WebXR + rosbridge: 브라우저 기반 VR 로봇 제어

14. 클라우드 기술

14.1 왜 클라우드인가

자율주행 차량은 시간당 1~5TB 데이터를 생성한다. 인식 모델 학습에는 수천 GPU-시간이 필요하다. 클라우드는 선택이 아닌 필수 인프라다.

14.2 데이터 파이프라인

차량 (Edge)
  → 셀룰러/WiFi로 원시 로그 업로드
  → Object Storage (S3/GCS/Azure Blob)
  → 데이터 카탈로그 & 인덱싱 (시나리오 마이닝)
  → 자동 어노테이션 (기존 모델로 사전 라벨링)
  → 인간 어노테이션 (검증, 코너 케이스)
  → 데이터셋 버전 관리 (DVC, LakeFS)
  → 학습 클러스터
  → 모델 레지스트리
  → 검증 파이프라인 (오프라인 메트릭, SIL)
  → OTA 배포

14.3 핵심 기술

14.4 OTA (Over-the-Air) 업데이트

A/B 파티션: 비활성 파티션 업데이트 → 재부팅 시 전환
Delta 업데이트: 변경 바이트만 전송 (100-500MB vs 10+GB)
Staged 롤아웃: 1% → 모니터링 → 점진적 확대
Rollback: 이상 감지 시 이전 버전 복원

• 암호화 서명, 안전 상태에서만 적용, ISO 24089 표준

14.5 데이터 플라이휠

모델 배포 → 실주행 데이터 수집 → 실패 사례 자동 마이닝
→ 어노테이션 추가 → 재학습 → SIL 검증 → A/B 테스트 → 전체 배포
→ [반복]

15. 학습 로드맵

15.1 기초 (1-3개월)

15.2 중급 (3-6개월)

15.3 고급 (6-12개월)

16. References

공식 문서

1. NVIDIA CUDA Programming Guide
2. NVIDIA TensorRT Documentation
3. ROS2 Jazzy Documentation
4. CARLA Documentation
5. NVIDIA Isaac Sim Documentation
6. Autoware Documentation

핵심 논문

7. Li, Z., et al. (2022). "BEVFormer: Learning Bird's-Eye-View Representation from Multi-Camera Images via Spatiotemporal Transformers". ECCV 2022.
8. Hu, Y., et al. (2023). "Planning-Oriented Autonomous Driving (UniAD)". CVPR 2023 Best Paper.
9. Brohan, A., et al. (2023). "RT-2: Vision-Language-Action Models Transfer Web Knowledge to Robotic Control". arxiv.org/abs/2307.15818
10. Black, K., et al. (2024). "pi0: A Vision-Language-Action Flow Model for General Robot Control". arxiv.org/abs/2410.24164
11. Team, O., et al. (2024). "Octo: An Open-Source Generalist Robot Policy". octo-models.github.io
12. Kim, M., et al. (2024). "OpenVLA: An Open-Source Vision-Language-Action Model". arxiv.org/abs/2406.09246

GitHub 저장소

13. carla-simulator/carla
14. autowarefoundation/autoware
15. ApolloAuto/apollo
16. openvla/openvla
17. octo-models/octo
18. OpenDriveLab/UniAD
19. NVIDIA/Model-Optimizer

블로그 및 해설

20. NVIDIA: How DRIVE AGX Achieves Fast Perception
21. NVIDIA: Top 5 AI Model Optimization Techniques
22. Multi-Sensor Fusion Survey (MDPI)
23. VLA Models Overview (DigitalOcean)
24. NetApp: Data Pipeline for Autonomous Driving