2025.11.12 - #55 - Vulkan shader, Human Characters to Humanoid, Egocentric-10K, NVIDIA AD dataset, LiteTracker

[james-joobs]

[james-joobs]

Vulkan Compute Shader 이해하기

Vulkan Compute Shader 개념 이해

1. Vulkan이란?

Vulkan은 GPU를 직접 제어할 수 있는 저수준 그래픽/컴퓨팅 API입니다.

비유:

• OpenGL/DirectX = 자동차 (운전만 하면 됨)
• Vulkan = 레이싱 카 (엔진, 기어, 연료 분사 등을 직접 제어)

더 복잡하지만, 제대로 사용하면 훨씬 빠릅니다.

---

2. Compute Shader란?

일반적인 셰이더는 화면에 그림 그리기용이지만, Compute Shader는 GPU를 범용 계산기로 사용하는 것입니다.

** GAN 만들기 프로젝트에서는**: 신경망 연산(행렬 곱셈, 활성화 함수 등)을 GPU에서 병렬로 계산

---

GAN 만들기 프로젝트에서의 Vulkan 사용 흐름

전체 파이프라인 (LeakyReLU 예시로 설명)

┌─────────────────────────────────────────────────────────┐
│ 1. CPU에서 준비 단계 (Host)                              │
└─────────────────────────────────────────────────────────┘
    │
    ├─ 입력 데이터: [0.5, -0.3, 0.8, -1.2, ...] (수백만 개)
    │
    ├─ GPU 버퍼 생성 (메모리 할당)
    │   └─ inputBuffer: GPU 메모리 영역 A
    │   └─ outputBuffer: GPU 메모리 영역 B
    │
    └─ 데이터를 GPU로 전송 (CPU → GPU 복사)

┌─────────────────────────────────────────────────────────┐
│ 2. Compute Shader 준비                                   │
└─────────────────────────────────────────────────────────┘
    │
    ├─ GLSL 코드 작성 (C++ 문자열로 저장)
    │   ```glsl
    │   layout(local_size_x = 256) in;  // 한 작업 그룹 = 256 스레드
    │
    │   void main() {
    │       uint idx = gl_GlobalInvocationID.x;  // 현재 스레드 번호
    │       float val = inputData[idx];
    │       outputData[idx] = val > 0 ? val : val * 0.2;  // LeakyReLU
    │   }
    │   ```
    │
    ├─ GLSL → SPIR-V 컴파일 (GPU가 이해하는 바이트코드)
    │
    └─ Compute Pipeline 생성 (GPU 실행 프로그램)

┌─────────────────────────────────────────────────────────┐
│ 3. GPU에 명령 전달                                       │
└─────────────────────────────────────────────────────────┘
    │
    ├─ Command Buffer (명령서) 작성
    │   ├─ "이 셰이더 사용해"
    │   ├─ "입력은 버퍼 A, 출력은 버퍼 B"
    │   └─ "1000개 작업 그룹 실행해" (= 256,000 스레드)
    │
    └─ GPU Queue에 제출 → GPU 실행 시작

┌─────────────────────────────────────────────────────────┐
│ 4. GPU에서 병렬 실행                                     │
└─────────────────────────────────────────────────────────┘
    │
    ├─ 스레드 0: inputData[0] 처리 → outputData[0]
    ├─ 스레드 1: inputData[1] 처리 → outputData[1]
    ├─ 스레드 2: inputData[2] 처리 → outputData[2]
    ├─ ...
    └─ 스레드 255,999: inputData[255999] 처리

    (모두 동시에 실행! 병렬 처리의 힘)

┌─────────────────────────────────────────────────────────┐
│ 5. 결과 받기                                             │
└─────────────────────────────────────────────────────────┘
    │
    ├─ GPU 실행 완료 대기 (동기화)
    └─ 결과를 CPU로 다시 복사 (필요한 경우)

---

핵심 개념 설명

1. Work Group (작업 그룹)

GPU는 수천 개의 스레드를 동시에 실행합니다. 이 스레드들을 관리 단위로 묶은 것이 Work Group입니다.

GAN 만들기 프로젝트의 설정:

local_size_x = 256  // 한 그룹에 256개 스레드

예시: 100,000개 데이터 처리

• Work Group 개수: 100,000 ÷ 256 = 391개
• 총 스레드: 391 × 256 = 100,096개 (약간 여유 있게)
• 각 스레드는 자기 인덱스(gl_GlobalInvocationID)에 해당하는 데이터 1개만 처리

---

2. Buffer (버퍼)

GPU 메모리 영역입니다. CPU의 배열과 비슷하지만, GPU 전용 메모리에 있습니다.

GAN 만들기 프로젝트의 버퍼 사용:

┌─────────────────┐
│ Input Buffer    │  ← 신경망 레이어 입력 데이터
│ [0.5, -0.3, ...│
└─────────────────┘
        │
        ↓ (Compute Shader 실행)
┌─────────────────┐
│ Output Buffer   │  ← 계산 결과
│ [0.5, -0.06, ..│
└─────────────────┘

버퍼 종류 (Usage Flags):

• STORAGE_BUFFER: 읽기/쓰기 가능 (신경망 데이터용)
• UNIFORM_BUFFER: 읽기 전용 (파라미터용, 예: LeakyReLU의 alpha=0.2)
• TRANSFER_SRC/DST: CPU ↔ GPU 전송용

---

3. Descriptor Set (자원 바인딩)

Shader에게 "어떤 버퍼를 사용할지" 알려주는 설정입니다.

비유: 함수 호출의 매개변수 전달

// CPU 함수
leakyRelu(input, output, alpha);

// GPU Shader에서는 Descriptor Set으로 전달
binding 0 = input buffer
binding 1 = output buffer
binding 2 = alpha (uniform)

---

4. Pipeline (파이프라인)

Shader 실행 설정의 묶음입니다.

포함 내용:

1. 어떤 셰이더 코드 사용?
2. 입력/출력 버퍼 레이아웃은?
3. 상수(push constants)는?

GAN 만들기 프로젝트에서는 각 레이어마다 Pipeline을 만듭니다:

• LeakyReLU Pipeline
• BatchNorm Pipeline
• Convolution Pipeline
• ...

---

5. Command Buffer (명령 버퍼)

GPU에게 전달할 명령들을 기록한 리스트입니다.

비유: 요리 레시피

1. 팬을 달군다 (Pipeline 바인딩)
2. 재료를 넣는다 (Descriptor Set 바인딩)
3. 볶는다 (Dispatch - 실제 Shader 실행)
4. 접시에 담는다 (Memory Barrier - 동기화)

GAN 만들기 프로젝트의 신경망 실행:

CommandBuffer 시작
  ├─ Layer 1 (LeakyReLU) 실행
  ├─ Memory Barrier (Layer 1 완료 대기)
  ├─ Layer 2 (BatchNorm) 실행
  ├─ Memory Barrier
  ├─ Layer 3 (Convolution) 실행
  └─ ...
CommandBuffer 제출 → GPU 실행

---

6. Queue (큐)

GPU의 작업 대기열입니다.

GPU는 여러 종류의 큐를 가집니다:

• Compute Queue: 계산 작업 (GAN 만들기 프로젝트가 주로 사용)
• Graphics Queue: 화면 그리기
• Transfer Queue: 메모리 전송

실행 방식:

queue << commandBuffer << waiting;  // 명령 제출하고 완료까지 대기

---

실제 코드 흐름 예시 (LeakyReLU)

CPU 측 (neuralNodes.cpp)

1. 셰이더 코드 문자열 준비
   ↓
2. Pipeline 생성
   - GLSL → SPIR-V 컴파일
   - Descriptor Set Layout 생성 (input/output 버퍼 레이아웃)
   ↓
3. run() 호출 시
   - input/output 버퍼 Descriptor Set에 바인딩
   - Work Group 개수 계산: (데이터 크기 ÷ 256)
   - CommandBuffer에 기록:
     * Pipeline 바인딩
     * Descriptor Set 바인딩
     * Dispatch(work_groups)
   ↓
4. GPU 실행 대기

GPU 측 (Compute Shader)

#version 450

layout(local_size_x = 256) in;  // 256 스레드/그룹

layout(binding = 0) buffer InputBuffer {
    float data[];
} inputData;

layout(binding = 1) buffer OutputBuffer {
    float data[];
} outputData;

layout(push_constant) uniform Params {
    float alpha;  // 0.2
};

void main() {
    uint idx = gl_GlobalInvocationID.x;  // 0, 1, 2, ...

    float val = inputData.data[idx];
    outputData.data[idx] = val > 0.0 ? val : val * alpha;
}

실행 과정:

• GPU가 256개 스레드를 동시에 실행
• 각 스레드는 자기 인덱스의 데이터 1개만 처리
• 모든 스레드가 병렬로 동작 → 엄청난 속도

---

왜 이렇게 복잡한가?

CPU vs GPU 비교

CPU로 LeakyReLU 계산:

for (int i = 0; i < 1000000; i++) {
    output[i] = input[i] > 0 ? input[i] : input[i] * 0.2;
}
// 순차 실행: 1→2→3→...→1,000,000
// 시간: ~10ms

GPU로 계산:

1,000,000개를 동시에 처리!
시간: ~0.1ms (100배 빠름)

대신 준비 과정이 복잡:

• 버퍼 생성
• 셰이더 컴파일
• Pipeline 설정
• 데이터 전송
• ...

하지만 한 번 설정하면 계속 재사용 가능 → 신경망처럼 반복 연산이 많으면 엄청난 이득!

---

GAN 만들기 프로젝트의 Vulkan 구조 요약

┌──────────────────────────────────────────────────────┐
│ VulkanApp (vulkanApp.cpp)                            │
│ - Vulkan 인스턴스 관리                                │
│ - 디바이스 선택 (GPU 선택)                            │
│ - Queue 생성                                          │
└──────────────────────────────────────────────────────┘
                    │
        ┌───────────┴──────────┬─────────────┐
        ↓                      ↓             ↓
┌─────────────┐    ┌─────────────┐    ┌──────────────┐
│ Buffer      │    │ Pipeline    │    │ CommandBuffer│
│ (GPU 메모리) │    │ (셰이더설정) │    │ (명령 기록)   │
└─────────────┘    └─────────────┘    └──────────────┘
        │                   │                │
        └───────────┬───────┴────────────────┘
                    ↓
        ┌─────────────────────┐
        │ Queue.submit()      │
        │ → GPU 실행!         │
        └─────────────────────┘

---

핵심 포인트 정리

1. Vulkan Compute Shader = GPU를 범용 계산기로 사용
2. 병렬성: 수천~수만 개 스레드가 동시 실행
3. 버퍼: GPU 메모리 (입력/출력 데이터 저장)
4. Pipeline: Shader + 설정의 묶음
5. Command Buffer: GPU 명령어 리스트
6. Queue: 명령 제출 → GPU 실행

GAN 만들기 프로젝트는: 각 신경망 레이어를 Compute Shader로 구현하여 GPU에서 병렬로 실행하는 구조입니다!

[blossominkyung]

Human Characters to Humanoid

• the intersection of physics-based motion generation and humanoid control -- aiming to bridge human motion understanding and physically-plausible robot control.

1. 전통적인 접근 (Inverse Dynamics)

• 시스템 동역학 방정식 $\tau = M(q)\ddot{q} + C(q, \ddot{q}) + g(q)$을 풀어 각 관절 토크를 계산
• 목표 trajectory (위치, 속도, 가속도)를 미리 정의하고 그에 맞춰 제어
• 강한 물리 모델 기반이라 안정적이고 수학적으로 해석 가능, 특정 태스크에 높은 정밀도를 보임
• 예측 불가능한 외력, 고차원 비선형 시스템에서는 generalization이 어렵고, 실시간 최적화 계산 비용 큼
• 모션의 자연스러움이나 adaptation 부족

정확히 계산하는 것에 초점을 두고 있지만, 환경과의 상호작용을 예측적으로 학습하지 않음

2. Simulation + Learning

• MuJoCo, IsaacGym 같은 물리 시뮬레이터 상에서 동적 상호작용을 하며 learning-based로의 전환
• single trajectory가 아닌, behavior policy를 학습 할 수 있고
• 결과적으로 inverse dynamics의 명시적 계산이 없어도 물리적 일관성을 유지할 수 있게 됨

GPU 병렬 시뮬레이션의 등장으로 policy를 수천번 빠르게 roll-out할 수 있게 됨
제어의 analytic model에서 experience-based model로 전환

3. Physics-based Control

• policy가 직접 토크나 힘을 산출, 시뮬레이터의 물리 법칙 내에서 검증
• imitation + reinforcement learning을 통해 reference motion과 환경 반응을 동시에 학습
• 물리 시뮬레이터 내에서 RL or IL로 policy를 학습해서, controller를 직접 설계하지 않고 데이터로부터 학습
• 데이터는 대규모 모션 데이터로, AMASS, LAFAN을 많이 사용하고 스켈레톤 캐릭터로 SMPL, SMPLX를 많이 사용
• 대표 연구
  • DeepMimic (mocap motion imitation via PPO)
  • AMP (adversarial reward로 human motion distribution)
  • PHC (multi-skill, multi-stage hierarchical policy)
  • UniPhys (generative model + RL -> generative control)

physics-based control은 시뮬레이션 내에서 운동학적으로 타당한 모션을 근사하는게 아니라,
물리적 안정성 내에서 자연스러운 모션을 학습하는 것
즉 휴머노이드가 설계된 controller로 움직이는게 아니라, 경험으로 학습된 intelligence로 움직인다

4. Character Control to Humanoid

• Sim-to-Real:
  • Character -> Physically Simulated Humanoid -> Retargeted Humanoid Robot
• Research Pipeline
  • Larget Motion Dataset,
  • Diffusion, RL hybrid controller
  • Retargeting & Deployment
• 연구 트랜드
  • Generative Motion Policy (Diffusion-based)
  • RL-based Control Adaptation (mimic-based)

character control이 단순히 모션 학습이었다면
humanoid control은 물리적 조정능력 + 환경 적응력 + 실시간성 등을 함께 요구
즉, From Motion Imitation -> Motion Intelligence

---

이 분야에 관심이 있으신 분들은!

1. Kris Kitani(https://kriskitani.github.io/)
2. Xiaolong Wang(https://xiaolonw.github.io/)
3. Karen Liu(https://www.cs.stanford.edu/people/karen-liu)
4. Jason Peng(https://xbpeng.github.io/)
5. Zen Luo(https://www.zhengyiluo.com/)

[changh95]

Egocentric-10K 데이터셋

• 10,000 hours
• 2,153 factory workers
• 1,080,000,000 frames
• Egocentric 데이터셋 + 양손의 움직임
• https://huggingface.co/datasets/builddotai/Egocentric-10K

Physical AI Autonomous Driving 데이터셋

• 97TB ㅋ.ㅋ
• total of 1727 hours of driving recorded from planned data-collection drives in 25 countries and 2500+ cities.
• Captures diverse traffic, weather conditions, obstacles, and pedestrians in the environment.
• Consists of 310,895 clips that are each 20 seconds long.
• The sensor data includes multi-camera and LiDAR coverage for all clips, and radar coverage for 163,850 clips.

딴소리

• 휴 살걸,,,,,,

LiteTracker: Leveraging Temporal Causality for Accurate Low-latency Tissue Tracking

• https://github.com/ImFusionGmbH/lite-tracker
• 원 글 레포는 비위가 약한 분은 누르지 마세요!
• 수술 영상에서 tissue tracking을 위해 만들어진 트래커
• 근데 일반 이미지에서도 잘됨

Screen.Recording.2025-11-12.at.8.44.08.PM.mov