개념
가우시안 하나가 담는 것
3차원 가우시안 하나는 공간 속의 매개변수화된 덩어리(blob)이며 다음 속성(attribute)을 가집니다.
position mu (3,) 월드 좌표(world coordinate)에서의 중심
rotation q (4,) 방향을 인코딩하는 단위 쿼터니언(unit quaternion)
scale s (3,) 축별 로그 스케일(렌더 시점에 지수화)
opacity alpha (1,) 시그모이드(sigmoid) 이후 불투명도 [0, 1]
SH coefficients c_lm (3 * (L+1)^2,) 시점 종속(view-dependent) 색
회전과 스케일을 합치면 3x3 공분산(covariance) 행렬이 만들어집니다. Sigma = R S S^T R^T입니다. 이것이 3차원에서 가우시안의 모양입니다. 구면 조화 함수는 색이 보는 방향에 따라 달라지게 해 줍니다. 시점별 텍스처(texture) 없이도 정반사 강조(specular highlight), 미묘한 광택(subtle sheen), 시점 종속 광택(view-dependent glow)을 표현할 수 있습니다. SH 차수(degree) 3이면 색 채널(channel)마다 계수(coefficient) 16개, 즉 색만 가우시안 하나당 48개의 부동소수점을 사용합니다.
장면 하나는 보통 100만에서 500만 개의 가우시안을 가집니다. 각 가우시안은 대략 60개의 부동소수점을 저장합니다(3 + 4 + 3 + 1 + 48 + 기타). 500만 가우시안의 장면은 약 240MB입니다. 점마다 텍스처를 가진 동등한 점 구름(point cloud)보다 훨씬 작고, 같은 해상도로 다시 렌더링하는 NeRF의 MLP 가중치보다도 한 자릿수 정도 작습니다.
광선 행진(ray marching)이 아니라 래스터화
flowchart LR
SCENE["수백만 개 3D Gaussian<br/>(position, rotation, scale,<br/>opacity, SH colour)"] --> PROJ["2D로 project<br/>(camera extrinsics + intrinsics)"]
PROJ --> TILES["Tile에 할당<br/>(16x16 screen-space)"]
TILES --> SORT["Tile별 depth-sort"]
SORT --> ALPHA["Front-to-back<br/>alpha composite"]
ALPHA --> PIX["Pixel colour"]
style SCENE fill:#dbeafe,stroke:#2563eb
style ALPHA fill:#fef3c7,stroke:#d97706
style PIX fill:#dcfce7,stroke:#16a34a
다섯 단계이며 모두 GPU에 잘 맞습니다. 픽셀마다 MLP를 질의할 필요가 없습니다. RTX 3080 Ti 한 장으로 600만 스플랫을 147fps로 렌더링합니다.
사영(projection) 단계
월드 좌표 mu와 3차원 공분산 Sigma를 가진 3차원 가우시안은, 스크린 좌표 mu'와 2차원 공분산 Sigma'를 가진 2차원 가우시안으로 사영됩니다.
mu' = project(mu)
Sigma' = J W Sigma W^T J^T (2 x 2)
W = 시점 변환(viewing transform; 카메라의 회전 + 평행이동)
J = mu'에서의 원근 사영(perspective projection)의 야코비안(Jacobian)
2차원 가우시안의 자취(footprint)는 Sigma'의 고유벡터(eigenvector)를 축으로 하는 타원(ellipse)입니다. 이 타원 안의 모든 픽셀은 exp(-0.5 * (p - mu')^T Sigma'^-1 (p - mu'))로 가중된 가우시안의 기여를 받습니다.
알파 합성 규칙
한 픽셀에 대해, 그 픽셀을 덮는 가우시안들은 뒤에서 앞(back-to-front) 순으로 정렬됩니다. 동등하게는 앞에서 뒤(front-to-back) 순으로 정렬하면서 역공식을 사용할 수도 있습니다. 색은 1980년대 이후 모든 반투명(semi-transparent) 래스터라이저가 사용해 온 식 그대로 합성됩니다.
C_pixel = sum_i alpha_i * T_i * c_i
T_i = prod_{j < i} (1 - alpha_j) i까지의 투과율(transmittance)
alpha_i = opacity_i * exp(-0.5 * d^T Sigma'^-1 d) 지역 기여
c_i = eval_SH(SH_i, view_direction) 시점 종속 색
이것은 NeRF의 부피 렌더링(volumetric render)과 같은 식입니다. 다만 광선을 따라 조밀한 표본을 뽑는 대신, 명시적인 희소(sparse) 가우시안 집합 위에서 계산합니다. 이 동일성 때문에 렌더링 품질이 NeRF에 견줄 만합니다. 둘 다 같은 복사장 방정식(radiance-field equation)을 적분하고 있기 때문입니다.
왜 미분 가능한가
사영, 타일(tile) 할당, 알파 합성, SH 평가 등 모든 단계가 가우시안 매개변수에 대해 미분 가능합니다. 정답 이미지가 주어지면 렌더링된 픽셀의 손실(loss)을 계산하고, 래스터라이저를 통해 역전파한 뒤, 경사 하강법(gradient descent)으로 모든 (mu, q, s, alpha, c_lm)을 갱신합니다. 약 30,000번의 반복(iteration) 동안 가우시안은 적절한 위치, 스케일, 색을 찾아갑니다.
조밀화(densification)와 가지치기(pruning)
고정된 가우시안 집합으로는 복잡한 장면을 덮을 수 없습니다. 학습에는 두 가지 적응적(adaptive) 메커니즘이 포함됩니다.
- 경사(gradient) 크기는 크지만 스케일이 작은 가우시안은 현재 위치에서 복제(clone)합니다. 이 영역에는 더 많은 세부 표현이 필요하다는 뜻입니다.
- 경사가 크고 스케일도 큰 가우시안은 두 개의 더 작은 가우시안으로 분할(split)합니다. 하나의 큰 가우시안이 너무 매끄러워 해당 영역을 잘 맞추지 못한다는 뜻입니다.
- 불투명도가 임계값(threshold) 아래로 떨어진 가우시안은 가지치기(prune)합니다. 더 이상 기여하지 않기 때문입니다.
조밀화는 N번의 반복마다 실행됩니다. 장면은 보통 SfM(Structure-from-Motion) 점에서 시드(seed)된 약 100k개의 초기 가우시안에서 시작해, 학습 끝에는 100만에서 500만 개로 커집니다.
구면 조화 함수를 한 문단으로
시점 종속 색은 단위 구(unit sphere) 위에서 정의된 함수 c(direction)입니다. 구면 조화 함수는 구 위의 푸리에 기저(Fourier basis)입니다. 차수 L에서 잘라내면 채널마다 (L+1)^2개의 기저 함수가 생깁니다. 새로운 시점에서 색을 평가한다는 것은, 학습된 SH 계수와 시점 방향에서 평가한 기저의 내적(dot product)을 구하는 일입니다. 차수 0은 계수 1개, 즉 상수 색입니다. 차수 3은 계수 16개이며 람베르트 음영(Lambertian shading), 정반사(specular), 약한 반사(mild reflection)를 잡아내기에 충분합니다. 3D Gaussian Splatting 논문들은 기본적으로 차수 3을 사용합니다.
2026년 운영 스택
1. Capture smartphone / DJI drone / handheld scanner
2. SfM / MVS COLMAP 또는 GLOMAP이 camera pose + sparse point를 산출
3. Train 3DGS nerfstudio / gsplat / inria official / PostShot (~10-30분, RTX 4090)
4. Edit SuperSplat / SplatForge (floater 정리, 분할)
5. Export .ply -> glTF KHR_gaussian_splatting 또는 .usd (OpenUSD 26.03)
6. View Cesium / Unreal / Babylon.js / Three.js / Vision Pro
4D와 생성형 변종
- 4D Gaussian Splatting: 가우시안이 시간의 함수가 됩니다. 부피 영상(volumetric video)에 사용됩니다(Superman 2026, A$AP Rocky의 "Helicopter").
- 생성형 스플랫(Generative splats): 전체 장면을 환각(hallucinate)으로 만들어 내는 텍스트-투-스플랫(text-to-splat) 모델입니다. 예: World Labs의 Marble.
- 3D Gaussian Unscented Transform: 자율 주행 시뮬레이션을 위한 NVIDIA NuRec의 변종입니다.
만들어 보기
Step 1: 2D 가우시안
먼저 2D 래스터라이저를 만듭니다. 3D 경우는 사영 뒤 바로 이 로직으로 귀결됩니다.
import torch
import torch.nn as nn
import torch.nn.functional as F
def eval_2d_gaussian(means, covs, points):
"""
means: (G, 2) 중심
covs: (G, 2, 2) 공분산 행렬
points: (H, W, 2) 픽셀 좌표
returns: (G, H, W) 각 가우시안의 픽셀별 밀도
"""
G = means.size(0)
H, W, _ = points.shape
flat = points.view(-1, 2)
inv = torch.linalg.inv(covs)
diff = flat[None, :, :] - means[:, None, :]
d = torch.einsum("gpi,gij,gpj->gp", diff, inv, diff)
density = torch.exp(-0.5 * d)
return density.view(G, H, W)
einsum은 모든 (가우시안, 픽셀) 쌍에 대해 이차 형식(quadratic form) diff^T Sigma^-1 diff를 계산합니다.
Step 2: 2D 스플래팅 래스터라이저
앞에서 뒤(front-to-back) 알파 합성입니다. 2D에서는 깊이(depth)가 의미를 갖지 않으므로, 순서를 결정하기 위해 가우시안마다 학습 가능한 스칼라를 둡니다.
def rasterise_2d(means, covs, colours, opacities, depths, image_size):
"""
means: (G, 2)
covs: (G, 2, 2)
colours: (G, 3)
opacities: (G,) [0, 1] 범위
depths: (G,) 정렬에 사용하는 가우시안별 스칼라
image_size: (H, W)
returns: (H, W, 3) 렌더링된 이미지
"""
H, W = image_size
yy, xx = torch.meshgrid(
torch.arange(H, dtype=torch.float32, device=means.device),
torch.arange(W, dtype=torch.float32, device=means.device),
indexing="ij",
)
points = torch.stack([xx, yy], dim=-1)
densities = eval_2d_gaussian(means, covs, points)
alphas = opacities[:, None, None] * densities
alphas = alphas.clamp(0.0, 0.99)
order = torch.argsort(depths)
alphas = alphas[order]
colours_sorted = colours[order]
T = torch.ones(H, W, device=means.device)
out = torch.zeros(H, W, 3, device=means.device)
for i in range(means.size(0)):
a = alphas[i]
out += (T * a)[..., None] * colours_sorted[i][None, None, :]
T = T * (1.0 - a)
return out
빠르지는 않습니다. 실제 구현은 타일 기반(tile-based) CUDA 커널을 사용합니다. 그러나 수학은 정확히 같고 전 과정이 미분 가능합니다.
Step 3: 학습 가능한 2D 스플랫 장면
class Splats2D(nn.Module):
def __init__(self, num_splats=128, image_size=64, seed=0):
super().__init__()
g = torch.Generator().manual_seed(seed)
H, W = image_size, image_size
self.means = nn.Parameter(torch.rand(num_splats, 2, generator=g) * torch.tensor([W, H]))
self.log_scale = nn.Parameter(torch.ones(num_splats, 2) * math.log(2.0))
self.rot = nn.Parameter(torch.zeros(num_splats))
self.colour_logits = nn.Parameter(torch.randn(num_splats, 3, generator=g) * 0.5)
self.opacity_logit = nn.Parameter(torch.zeros(num_splats))
self.depth = nn.Parameter(torch.rand(num_splats, generator=g))
def covs(self):
s = torch.exp(self.log_scale)
c, si = torch.cos(self.rot), torch.sin(self.rot)
R = torch.stack([
torch.stack([c, -si], dim=-1),
torch.stack([si, c], dim=-1),
], dim=-2)
S = torch.diag_embed(s ** 2)
return R @ S @ R.transpose(-1, -2)
def forward(self, image_size):
covs = self.covs()
colours = torch.sigmoid(self.colour_logits)
opacities = torch.sigmoid(self.opacity_logit)
return rasterise_2d(self.means, covs, colours, opacities, self.depth, image_size)
log_scale, opacity_logit, colour_logits는 모두 제약 없는(unconstrained) 매개변수이며 렌더 시점에 적절한 활성 함수(activation)를 통과합니다. 모든 3DGS 구현에서 사용하는 표준 패턴입니다.
Step 4: 2D 가우시안을 목표 이미지에 맞추기
import math
import numpy as np
def make_target(size=64):
yy, xx = np.meshgrid(np.arange(size), np.arange(size), indexing="ij")
img = np.zeros((size, size, 3), dtype=np.float32)
mask = (xx - 20) ** 2 + (yy - 20) ** 2 < 10 ** 2
img[mask] = [1.0, 0.2, 0.2]
mask = (np.abs(xx - 45) < 8) & (np.abs(yy - 40) < 8)
img[mask] = [0.2, 0.3, 1.0]
return torch.from_numpy(img)
target = make_target(64)
model = Splats2D(num_splats=64, image_size=64)
opt = torch.optim.Adam(model.parameters(), lr=0.05)
for step in range(200):
pred = model((64, 64))
loss = F.mse_loss(pred, target)
opt.zero_grad(); loss.backward(); opt.step()
if step % 40 == 0:
print(f"step {step:3d} MSE {loss.item():.4f}")
200번의 반복 동안 64개의 가우시안이 두 도형에 맞게 자리잡습니다. 이것이 전체 아이디어입니다. 명시적인 기하 원시(geometric primitive)를 경사 하강법으로 맞추는 것입니다.
Step 5: 2D에서 3D로
3D 확장은 같은 루프를 유지합니다. 추가되는 점은 다음과 같습니다.
- 가우시안별 회전이 단일 각도가 아니라 쿼터니언으로 표현됩니다.
- 공분산은 쿼터니언에서 만든
R과 S = diag(exp(log_scale))로 R S S^T R^T가 됩니다.
- 사영
(mu, Sigma) -> (mu', Sigma')는 카메라 외부 매개변수(extrinsics)와 mu에서의 원근 사영 야코비안을 사용합니다.
- 색은 구면 조화 함수 전개가 되며, 시점 방향에 대해 평가합니다.
- 깊이 정렬은 학습된 스칼라가 아니라 실제 카메라 좌표계의 z 값을 사용합니다.
모든 운영 구현(gsplat, inria/gaussian-splatting, nerfstudio)은 GPU 위에서 타일 기반 CUDA 커널로 정확히 이 작업을 수행합니다.
Step 6: 구면 조화 함수 평가
차수 3까지의 SH 기저는 채널마다 16개의 항을 가집니다. 평가는 다음과 같습니다.
def eval_sh_degree_3(sh_coeffs, dirs):
"""
sh_coeffs: (..., 16, 3) 마지막 차원은 RGB 채널
dirs: (..., 3) 단위 벡터
returns: (..., 3)
"""
C0 = 0.282094791773878
C1 = 0.488602511902920
C2 = [1.092548430592079, 1.092548430592079,
0.315391565252520, 1.092548430592079,
0.546274215296039]
x, y, z = dirs[..., 0], dirs[..., 1], dirs[..., 2]
x2, y2, z2 = x * x, y * y, z * z
xy, yz, xz = x * y, y * z, x * z
result = C0 * sh_coeffs[..., 0, :]
result = result - C1 * y[..., None] * sh_coeffs[..., 1, :]
result = result + C1 * z[..., None] * sh_coeffs[..., 2, :]
result = result - C1 * x[..., None] * sh_coeffs[..., 3, :]
result = result + C2[0] * xy[..., None] * sh_coeffs[..., 4, :]
result = result + C2[1] * yz[..., None] * sh_coeffs[..., 5, :]
result = result + C2[2] * (2.0 * z2 - x2 - y2)[..., None] * sh_coeffs[..., 6, :]
result = result + C2[3] * xz[..., None] * sh_coeffs[..., 7, :]
result = result + C2[4] * (x2 - y2)[..., None] * sh_coeffs[..., 8, :]
return result
학습된 sh_coeffs는 해당 가우시안의 "모든 방향에서의 색"을 저장합니다. 렌더 시점에는 현재 시점 방향에 대해 평가해 RGB 3차원 벡터를 얻습니다.
사용해 보기
실제 3DGS 작업에는 gsplat(Meta) 또는 nerfstudio를 사용합니다.
pip install nerfstudio gsplat
ns-download-data example
ns-train splatfacto --data path/to/data
splatfacto는 nerfstudio의 3DGS 학습 도구입니다. 일반적인 장면은 RTX 4090에서 10-30분 정도 소요됩니다.
2026년에 중요한 내보내기(export) 옵션은 다음과 같습니다.
.ply: 원시(raw) 가우시안 구름입니다. 이식성이 좋지만 파일이 가장 큽니다..splat: PlayCanvas / SuperSplat 양자화(quantised) 포맷입니다.- glTF
KHR_gaussian_splatting: Khronos 표준이며 뷰어(viewer) 간 이식성이 있습니다(2026년 2월 RC).
- OpenUSD
UsdVolParticleField3DGaussianSplat: USD 네이티브 포맷이며 NVIDIA Omniverse와 Vision Pro 파이프라인에 적합합니다.
4D 또는 동적(dynamic) 장면에는 4DGS와 Deformable-3DGS가 같은 구조를 시간 변화 평균(mean)과 불투명도로 확장합니다.
산출물 만들기
이 강의에서는 다음을 만듭니다.
outputs/prompt-3dgs-capture-planner.md: 주어진 장면 유형에 대해 사진 수, 카메라 경로, 조명을 포함한 촬영 세션 계획을 세우는 프롬프트(prompt)입니다.outputs/skill-3dgs-export-router.md: 후속 뷰어나 엔진에 따라 적절한 내보내기 형식(.ply / .splat / glTF / USD)을 고르는 스킬(skill)입니다.
연습문제
- (쉬움) 다른 합성(synthetic) 이미지에서 위의 2D 스플랫 학습기를 실행해 봅니다.
num_splats를 [16, 64, 256]으로 바꾸고 각 경우의 MSE 대 학습 단계 곡선을 그립니다. 효율이 떨어지기 시작하는 한계점(diminishing returns)을 찾습니다.
- (중간) 2D 래스터라이저를 확장해, 가우시안별 RGB 색이 차수 2 조화 함수를 통해 스칼라 "시점 각도"에 의존하도록 만듭니다. 목표 이미지 쌍에 대해 학습하고 두 이미지를 모두 재구성하는지 확인합니다.
- (어려움)
nerfstudio를 복제(clone)하고, 책상, 식물, 얼굴, 방 등 직접 촬영한 20장 사진 장면에서 splatfacto를 학습합니다. glTF KHR_gaussian_splatting으로 내보내고 뷰어(Three.js GaussianSplats3D, SuperSplat, Babylon.js V9)에서 엽니다. 학습 시간, 가우시안 수, 렌더링 fps를 보고합니다.
핵심 용어
| 용어 | 흔한 설명 | 실제 의미 |
|---|
| 3DGS | "가우시안 스플랫" | 위치, 회전, 스케일, 불투명도, SH 색을 가진 수백만 개의 3차원 가우시안으로 장면을 표현하는 명시적 표현 |
| 공분산(Covariance) | "가우시안의 모양" | Sigma = R S S^T R^T; 가우시안 하나의 방향과 비등방(anisotropic) 스케일 |
| 알파 합성(Alpha compositing) | "뒤에서 앞으로 섞기" | NeRF의 부피 렌더링과 같은 식을 명시적인 희소 집합 위에서 계산하는 것 |
| 조밀화(Densification) | "복제와 분할" | 재구성이 부족한(under-fit) 곳에 새 가우시안을 적응적으로 추가하는 과정 |
| 가지치기(Pruning) | "낮은 불투명도 삭제" | 학습 중 불투명도가 거의 0으로 무너진 가우시안을 제거하는 것 |
| 구면 조화 함수(Spherical harmonics) | "시점 종속 색" | 구 위의 푸리에 기저. 시점 방향의 함수로 색을 저장한다 |
| Splatfacto | "nerfstudio의 3DGS" | 2026년에 3DGS를 학습하는 가장 쉬운 경로 중 하나 |
KHR_gaussian_splatting | "glTF 표준" | 2026년 Khronos 확장. 3DGS를 뷰어와 엔진 사이에서 이식 가능하게 한다 |
더 읽을거리