2025.05.07 - #34 - NVIDIA/AMD/Google/Furiosa GPU NPU TPU 리뷰, Differentiable rendering 리뷰

[changh95]

NVIDIA GPU, Google TPU, AMD GPU, Furiosa NPU 비교

NVIDIA GPU (A100, H100, H200, B200)

• 공부하기 좋은 리소스: https://comsys-pim.tistory.com/6

Streaming multiprocessors (SM)

• CUDA core (FP32/FP64) + Tensor core (matrix math)
• A100: 108 SMs -> FP64, FP32, FP16, BF16, INT8, INT4 matrix ops
• H100: 132 SMs -> FP64, FP32, FP16, BF16, FP8 (transformer engine)
  • 2x tensor FLOPS than A100
• H200: Better memory and power than H100
• B200: 2 x 132 SMs (Dual chiplet, connected by NVLink-C2C) -> FP64, FP32, FP16, BF16, FP8, INT8, INT4, FP4
  • 2x tensor FLOPS than H200

Memory

• A100: 40MB L2 cache, HBM2 (40GB @1.6TB/s, 80GB @2.0TB/s)
• H100: 50MB L2 cache, HBM3 (80GB @3.35B/s, 94GB@3.9TB/s)
• H200: HBM3e (141 GB @4.8TB/s)
• B200: 100MB L2 cache, 8+ HBM3e (192GB @5.3TB/s)

AMD GPU (MI250, MI300)

• GPU based, but pure compute focus

Compute Dies

• MI250X (2021 - CDNA2)
  • 2 GPU chiplets - 2 x 110 compute units (Graphics Compute Die - GCD), optimized for FP64 and matrix math
  • Matrix cores - FP16, BF16
• MI300 (2023, CDNA3)
  • 8 GPU chipets - 304 compute units (Accelerator Complex Dies - XCDs)
  • Matrix cores - FP16, BF16, INT8, FP8
  • Comparable to H100's raw compute

Memory

• MI250X: 8MB L2 cache per GCD, HBM2e (128GB @3.2TB/s)
• MI300X, 256 'AMD Infinity Cache', HBM3 (192GB @5.3TB/s)

Google TPU (v4, v5e)

• Systolic array core

Processors (TensorCores - large matrix multiply units, SparseCores - Sparse computation)

• TPU v4: 2 TensorCores per chip -> BF16, INT8 (275 TFLOPS per chip for BF16!)
• TPU v5e: 1 TensorCore per chip -> BF16, INT8 (197 TFLOPS for BF16, 393 INT8 TOPS)
• Both uses SparseCores, specialized for embedding vectors, which significantly speed up recommendation and language models with large embedding tables.
• Google uses BF16 for training, and INT8 for inference, and does NOT support FP8 (for v4 and v5e)

Memory

• TPU v4: HBM2 (16GB @1.2 TB/s), Local SRAM 64MB
• TPU v5e: HBM2e (16GB @819 GB/s),
• TPU v5p: HBM3 (95GB @2.8 TB/s)
• TPU v6: HBM3 (192GB @7.4 TB/s)

Architecture

• Scale up:
  • TPU v4: 4092 chips in a 'pod'
    • 아래 이미지는 1개의 'pod' 중의 1/8 이라고 함
    • 4x4x4 shape -> 3D torus network
  • TPU v5e: 256 chips in a 'pod' for smaller deployment
  • TPU v6: 256 chips in a 'pod', or 9216 chips in a 'pod'

Furiosa NPU

Processor (Tensor Contraction Processors - TCP)

• Warboy: 2 TCP cores, FP32, FP16, BF16, FP8, INT8
  • 32 TOPS INT8, 4 TFLOPS FP16
• RNGD: 8 TCP cores
  • 32 BF16 TFLOPS, 64 TFLOPS FP8 for each core -> 256 TFLOPS BF16, 512 TFLOPS FP8, 1024 TOPS INT4.

Memory

• Warboy: 16GB LPDDR4X (@66GB/s), 32MB on-chip SRAM
• RNGD: 48GB HBM3 (@1.5TB/S), 256 MB on-xhip SRAM

[james-joobs]

📘 Differentiable Rendering 정리

기반 논문: Modular Primitives for High-Performance Differentiable Rendering
https://github.com/NVlabs/nvdiffrast

---

🧭 개요 및 배경

🔍 왜 Differentiable Rendering이 필요한가?

• 우리는 주로 2D 이미지만 관찰할 수 있음
• 그러나 관심 있는 대상은 3D 구조, 조명, 포즈 등
• 따라서 2D 이미지를 보고 3D 정보를 추정하는 방식이 필요함

→ 이를 위해 "Analysis-by-Synthesis" 방식 사용:

1. 3D 파라미터를 가정
2. 이를 렌더링하여 2D 이미지 생성
3. 실제 이미지와 비교 (Loss 계산)
4. 오차를 3D 파라미터로 역전파

• 이 과정에서 렌더링이 미분 가능해야 함

---

🔧 미분 가능한 렌더링의 구성 요소

전체 파이프라인 구조

flowchart TD
    Input[Scene Parameters (Mesh, Texture, Camera, Light)] --> Raster
    Raster --> Interpolate --> Filter --> Shade --> Blend --> Rendered[Rendered Image]
    Rendered --> Loss
    Loss --> Backprop[∂L/∂θ]

---

🎯 이 논문의 Design Goal & System Design

📌 설계 목표 (G1–G4)

Goal	내용
G1	GPU를 활용한 고성능 실행
G2	PyTorch 등과의 연동을 위한 최소 인터페이스
G3	쉐이딩, geometry 등 커스터마이징 가능성 확보
G4	고화질 이미지 및 안정적인 gradient 보장

⚙️ 설계 선택 (C1–C6)

선택 항목	설명
C1	모든 단계를 모듈형 primitive로 분리 (Rasterize, Interpolate 등)
C2	Tensor 기반 입출력으로 PyTorch 호환성 유지
C3	camera 변환은 외부에서 수행, 렌더러는 clip-space 처리만
C4	deferred shading 구성 (raster → interpolate → shade)
C5	analytic antialiasing으로 visibility gradient 생성
C6	geometry는 triangle mesh에 한정해 효율 극대화

---

🧩 핵심 구성 1: Texture Filtering (Figure 2)

기여 대상: 텍스처와 UV 좌표 학습

• MIP-map 기반 다단계 필터링
• UV좌표 및 텍스처 이미지 모두에 gradient 전달 가능

---

🧩 핵심 구성 2: Analytic Antialiasing (Figure 3)

기여 대상: 실루엣에서의 geometry (vertex 위치) 학습

• 픽셀 간 triangle ID가 바뀌는 경계 감지
• 실루엣의 위치를 선형 함수로 근사하여 vertex 위치에 gradient 생성 가능

---

🔦 Path Tracing 기반 Differentiable Rendering

전통적 rasterization 외에도, 현실적인 조명과 반사를 표현하려면 Path Tracing 기반 미분 렌더링이 필요하다.

구성 요소	설명
Forward	Monte Carlo 방식으로 다중 반사/굴절 등을 추적하여 realistic image 생성
Backward	Sampling path의 확률적 성질로 인해 gradient가 stochastic 하며 노이즈 많음

해결 방안:

• importance sampling
• reparameterization trick
• control variates 기법 활용 등

📌 적용 예:

• Material/BRDF parameter 학습
• 조명 위치 및 색상 추정
• indirect illumination 기반 3D scene reconstruction

📌 참고 이미지 키워드:

• differentiable path tracing
• redner differentiable rendering

---

🧠 미분 가능한 렌더링의 출력/입력 및 학습 흐름

구성	설명
입력	2D Ground Truth 이미지 (I_target)
학습 파라미터 (θ)	mesh vertex, texture map, camera pose, light 등
출력	렌더된 2D 이미지 (I_rendered)
손실함수	L = MSE(I_rendered, I_target) 등
학습 대상	3D geometry, texture, pose, light 등

---

🧠 어떤 딥러닝 모델을 어떻게 구성해야 하나?

🎯 선택 기준: 어떤 scene parameter를 학습하느냐에 따라 달라짐

목적	예시 모델 구조
shape/polygon fitting	nn.Parameter(vertices) 를 직접 최적화
이미지 → pose 추정	ResNet → Linear Head → pose
이미지 → shape+pose	CNN → shape & pose head → morphable model + renderer
texture map 학습	nn.Parameter(texture) 선언 후 렌더링 경유
NeRF류	MLP(xyz) → color, density 출력

# 예시: 이미지 → 3D pose 학습 구조
class PoseNet(nn.Module):
    def __init__(self):
        ...
        self.pose_head = nn.Linear(512, 6)
        self.shape_head = nn.Linear(512, 100)

    def forward(self, x):
        ... → mesh → render(mesh, pose)

---

🔁 전체 학습 흐름 예시

for step in range(N):
    θ_pred = model(image)
    I_rendered = renderer(θ_pred)
    loss = F.mse_loss(I_rendered, I_target)
    loss.backward()
    optimizer.step()

• Figure 2는 texture/UV 경로로 gradient 전파
• Figure 3은 geometry(edge/silhouette) 경로로 gradient 전파
• Path Tracing 기반이라면 material/light 등도 역전파 대상

---

Figure 10: 재구성된 프레임 예시

• 89프레임 시퀀스 중 하나의 프레임에 대해 실제 이미지와 렌더링 결과를 비교
• (a): 실제 카메라 이미지
• (b)-(d): 최적화된 텍스처 및 geometry로 렌더링된 결과 (와이어프레임 포함)
• (e): 초기 base mesh
• 입과 눈 주변의 복잡한 형태는 간략한 geometry로 인해 부정확하지만, 전체적인 형상과 텍스처는 매우 사실적으로 복원됨

---

Figure 11: 코 부분의 미세한 움직임 비교

• “Neutral”과 “Disgust” 시퀀스에서 코 주변을 클로즈업하여 비교
• 기존 DI4D 방식보다 더 미세한 움직임을 포착
• 차이 시각화 결과, 실루엣과 콧구멍 등 복잡한 부위까지 정밀하게 재현됨
• 디포커싱 효과 등으로 인해 일부 오차 존재

---

Figure 12: 전체 시퀀스 통합 최적화 결과

• “Neutral”, “Disgust”, “Anger” 시퀀스 419프레임 전체를 하나의 base mesh로 통합 최적화
• 동일 텍스처 사용 → 정합된 vertex-to-skin mapping 보장
• 일부 프레임에서 입 주변 아티팩트 발생했지만, 시간적 일관성과 텍스처 품질 우수

---

🧠 요약

Differentiable Rendering은:

• 2D 이미지 기반으로 3D 파라미터를 학습 가능하게 하고
• 그를 위해 렌더링 파이프라인을 구성 요소 단위로 미분 가능하게 만들며
• texture filtering과 antialiasing 같은 정교한 처리 덕분에 고품질 결과와 안정적 학습이 가능해진다.

이 논문은 그 구성요소를 모듈형으로 분리하고, 실제 딥러닝 학습 파이프라인에 바로 통합 가능하도록 설계했다는 점에서 매우 실용적이다.

또한 rasterization 기반뿐 아니라, Path Tracing 기반까지 확장 가능한 배경 이론과 응용 사례를 갖추고 있다.

---

📚 추천 추가 이미지/참고 키워드

• differentiable rendering pipeline overview
• soft rasterizer vs analytic rasterizer
• analysis by synthesis 3D fitting
• visibility gradient rendering
• differentiable path tracing brdf

---

[james-joobs]

Samuli Laine

joined NVIDIA Research in 2007 after receiving his Ph.D. at Helsinki University of Technology.

His research interests have ranged from photorealistic and real-time rendering to voxel-based graphics, GPU ray tracing, and 3D content creation. Currently Dr. Laine focuses on deep learning and its applications in computer graphics.

https://research.nvidia.com/person/samuli-laine

https://scholar.google.com/citations?user=UCXJOTUAAAAJ&hl=en