제10부 시뮬레이션·디지털트윈·피지컬 AI

10.5 합성데이터 I — Replicator 파이프라인

10.5.1 이 장에서 배우는 것 / 선수 지식

9.11(RTX 센서)에서 시뮬이 픽셀마다 완벽한 GT를 안다고, 9.12에서 Replicator로 그 데이터를 생성한다고 소개했다. 이 장은 그 합성데이터 생성(SDG, Synthetic Data Generation) 파이프라인을 본격적으로 판다 — Replicator가 USD 씬(10.3)·RTX 렌더(10.2)·도메인 랜덤화·annotator·writer를 엮어 라벨된 학습 데이터를 대량·결정적으로 생성하는 구조다. 도메인 랜덤화·자동 라벨의 심화는 10.6, Sim2Real 갭은 10.7 — 이 장은 파이프라인 아키텍처와 오케스트레이션(어떻게 생성 루프가 실행되는가, 어떻게 스케일하는가)에 집중한다.

핵심 통찰: 합성데이터는 "데이터 병목"을 푸는 데이터 공장이고, Replicator는 그 공장의 조립 라인이다. 인지(9.7~9.9)의 제약 요인은 모델이 아니라 라벨된 데이터 — 실데이터 라벨링은 비용이 크고·느리고·노이즈가 있고·일부 GT(정확한 깊이·3D 박스·가려진 객체)는 아예 못 잰다. 시뮬은 정반대로 픽셀마다 정답을 자동·완벽·무한·균형 있게 안다. Replicator는 이를 프로그래밍 가능한 파이프라인으로 만든다 — 씬을 세팅하고, 매 프레임 랜덤화 → 렌더 → GT 캡처 → 디스크 기록을 결정적으로·대량으로 실행한다. 헤드리스·멀티 GPU·클라우드로 수만~수백만 장을 생성해 모델을 학습시키고, 실패 케이스를 타깃 재생성하는 데이터 플라이휠(8.14)을 실행한다. 단 합성만으론 Sim2Real 갭(10.7)이 남는다.

배우는 것:

• 데이터 병목과 합성데이터 — 실데이터 라벨링의 한계(비용·노이즈·불가능 GT)와 합성의 답, 그 한계.
• Replicator — USD(10.3)·RTX(10.2)·랜덤화·annotator·writer를 엮는 SDG 프레임워크(Kit 확장 10.1).
• 생성 파이프라인 — 씬→랜덤화→트리거→렌더→annotator(GT)→writer의 구조·오케스트레이션.
• 결정성 — 시드로 재현 가능한 데이터셋, GPU 비결정 한계.
• 스케일·연결 — 헤드리스·멀티 GPU·클라우드 대량 생성, 학습(TAO·PyTorch) 연결, 데이터 플라이휠(8.14).

선수 지식: 9.11(RTX 센서·완벽 GT·Sim2Real)·9.12(Replicator 개요·SIL·데이터 플라이휠)·10.1(Kit·헤드리스)·10.2(RTX 렌더)·10.3·10.4(USD 씬·합성)·8.14(데이터 엔진)·7.7(플라이휠). 도메인 랜덤화·자동 라벨 심화는 10.6, Sim2Real 전이는 10.7. 인지 모델(검출·분할·깊이)·학습 파이프라인 기초는 가정(BK-02).

정직: Replicator의 API·annotator·writer·확장명은 릴리스 의존이 크다(Omniverse 플랫폼 위라 더). 이 장은 "SDG 파이프라인의 구조·오케스트레이션·스케일·결정성의 원리"를 가르치고, 구체 API·포맷·메뉴는 "그 릴리스 문서로 확인". 코드(omni.replicator)는 개념 골격. 합성데이터만으로는 충분하지 않다 — Sim2Real 갭(10.7)이 있어 도메인 랜덤화(10.6)·실데이터 혼합이 필요하고, 효과는 과제·충실도 의존이라 실데이터로 검증해야 함을 정직하게 둔다. 처리량·비용 수치는 환경 의존 개략값. Replicator는 RTX GPU(워크스테이션/서버/OVX, 엣지 아님 9.11).

10.5.2 데이터 병목과 합성데이터 — 왜

인지(9.7~9.9)·자율주행(8.14)의 실제 병목은 모델이 아니라 라벨된 데이터다.

   실데이터(real data)의 한계:
     · 라벨링 비용·시간 — 사람이 픽셀·박스를 일일이(분할은 한 장에 수십 분)
     · 라벨 노이즈     — 사람 라벨은 부정확·불일치(경계·가림·작은 객체)
     · 롱테일·위험     — 희귀·위험 장면(사고·고장)은 수집 자체가 어렵/위험(8.10·8.15)
     · 불가능한 GT     — 정확한 깊이·3D 박스·표면 법선·가려진(amodal) 객체는
                        실세계서 정밀 측정 곤란
     · 불균형          — 클래스·조건이 자연 분포라 희귀 클래스 부족

   합성데이터(synthetic)의 답:
     · 완벽·자동 라벨   — 시뮬이 픽셀마다 정답을 안다(9.11), 사람·비용 0
     · 무한·롱테일     — 희귀·위험 장면을 안전하게 무한 생성
     · 균형·제어       — 클래스·조건·시점을 의도대로
     · 불가능한 GT 제공 — 깊이·3D 박스·법선·amodal을 정확히

   대가: Sim2Real 갭(10.7) — 합성만으론 실분포와 달라 → DR(10.6)·실혼합

• 라벨링이 실질적 비용: 검출·분할 모델은 라벨이 필요한데, 실데이터 라벨링은 사람·시간·돈이 막대하고(분할은 특히), 라벨에 노이즈가 있다. 데이터 엔진(8.14)의 핵심 난점.
• 불가능한 GT: 정확한 깊이·3D 바운딩 박스·표면 법선·가려진 객체의 완전 형태(amodal) 는 실세계서 정밀히 못 잰다(LiDAR도 노이즈·희소). 시뮬은 정확히 안다 — 합성만의 강점.
• 롱테일·위험(8.10·8.15): 사고·고장·희귀 상황은 실수집이 어렵고 위험. 시뮬은 안전하게 무한 생성 — 자율주행·로봇 안전의 데이터.
• 합성의 답과 한계: 완벽·무한·균형·불가능 GT를 주되, Sim2Real 갭(10.7) — 합성 분포가 실분포와 달라 합성만 학습하면 실세계 취약. 도메인 랜덤화(10.6)·실데이터 혼합으로 좁힌다. 합성은 실데이터를 보강·대체(부분) 하지 단독으로는 충분하지 않다.

핵심: 인지의 병목은 라벨된 데이터 — 실라벨링은 비용이 크고·노이즈·롱테일 위험·일부 GT(깊이·3D·amodal) 불가능. 합성데이터는 완벽·자동·무한·균형·불가능 GT로 이를 푼다. 대가는 Sim2Real 갭(10.7) — DR(10.6)·실혼합 필요. Replicator는 이 합성데이터를 공장처럼 생성하는 도구.

10.5.3 Replicator — USD·RTX 위의 데이터 생성 프레임워크

Replicator는 Omniverse의 합성데이터 생성 프레임워크 — USD 씬·RTX 렌더·랜덤화·annotator·writer를 엮어 라벨 데이터를 프로그래밍으로 생성한다.

토대는 아래에서 위로 쌓인다 — 맨 아래 Omniverse Kit이 토대, 그 위에 OpenUSD 씬·RTX 렌더·Replicator 오케스트레이션이 추가되고, 전체가 RTX GPU(워크스테이션/OVX) 위에서 실행된다.

• Kit 확장(10.1): Replicator는 omni.replicator.core 확장 — Kit 위에서 실행되고, 헤드리스로 GUI 없이 배치·클라우드 생성(10.1.5). Isaac Sim·USD Composer 등에 포함되거나 단독 헤드리스 앱으로.
• USD가 씬(10.3·10.4): 생성할 데이터의 씬(자산·환경·카메라·라이트)이 USD다 — references로 자산 재사용(10.4), 도메인 랜덤화가 USD 프림·속성을 변형(10.6). 데이터 모델이 데이터 생성의 토대.
• RTX가 엔진(10.2·9.11): 포토리얼 렌더(실시간 또는 패스트레이싱 10.2)로 사실적 이미지를, 그리고 GT annotator(분할·박스·깊이 9.11)를 출력. 갭 작은 데이터는 RTX 충실도에서.
• Python API로 정의: 생성 파이프라인을 코드로 정의(rep.create·rep.randomizer·rep.trigger·writer) — 절차적·재현 가능·스케일. GUI가 아니라 스크립트가 데이터 공장의 설계도.
• 로봇·자율주행·산업: 로봇 인지(9.7~9.9)·자율주행 인지(8.14·8.15)·제조 결함 검출 등 — 도메인 자산·랜덤화로 각 과제 데이터.

핵심: Replicator는 Kit(10.1) 위, USD 씬(10.3)·RTX 렌더(10.2·9.11)를 엮는 SDG 프레임워크다. Python API로 생성 파이프라인을 코드로 정의(재현·스케일), 헤드리스로 배치·클라우드 생성. USD가 씬, RTX가 렌더·GT 엔진, Replicator가 오케스트레이션. 데이터 모델(USD)이 데이터 공장으로.

10.5.4 생성 파이프라인 — 컴포넌트와 흐름

Replicator 파이프라인의 컴포넌트와 한 프레임의 흐름이 이 장의 핵심이다.

• ① 씬·자산(USD 10.3·10.4): 카메라(render product 대상)·라이트·대상 자산을 USD로 배치. 자산에 의미 라벨(semantics — "cube"·"person") 부여 → annotator가 이를 GT로. references로 자산 재사용(10.4).
• ② randomizer(개요): 매 생성마다 씬을 무작위 변형(위치·색·조명·카메라) → 다양한 데이터·일반화(Sim2Real 좁힘 10.6·10.7). 이 장은 "파이프라인의 한 단계"로만, 무엇을·얼마나의 전략은 10.6.
• ③ trigger(오케스트레이션): 생성 루프의 박자 — rep.trigger.on_frame(num_frames=N)이 "N번 반복하며 매번 randomizer 실행"을 지시. 간격·조건 트리거도. 파이프라인을 언제 몇 번 실행할지.
• ④ render(10.2): 랜덤화된 씬을 RTX로 렌더해 render product(이미지 출력) 생성. 실시간 또는 패스트레이싱(10.2 — 품질↔속도). 센서(카메라·LiDAR 9.11)별 출력.
• ⑤ annotator(GT, 개요): render product에서 정답을 추출 — RGB·depth·semantic/instance segmentation·2D/3D bbox·normals. 시뮬이 픽셀마다 정확히 안다(9.11). 종류·자동 라벨 정확성 심화는 10.6.
• ⑥ writer(출력): annotator 결과를 디스크에 포맷대로 — BasicWriter·KITTI·COCO·커스텀. 학습 파이프라인이 소비(10.5.7).
• 파이프라인 = 데이터 공장: 이 ①~⑥이 한 프레임이고, trigger가 N번 실행해 데이터셋을 생성한다. 각 단계가 모듈이라 조합·교체(다른 자산·랜덤화·annotator·포맷).

견해: 생성 파이프라인은 씬(USD)→randomizer(변형)→trigger(박자)→render(RTX)→annotator(GT)→writer(출력) 의 조립 라인이다 — trigger가 N번 실행해 데이터셋을 생성한다. 각 단계가 모듈이라 조합·교체(자산·랜덤화·annotator·포맷). 이 장은 파이프라인 구조·오케스트레이션에 집중 — randomizer 전략과 annotator 자동 라벨의 심화는 10.6. 공통 토대는 USD(씬)·RTX(렌더·GT).

10.5.5 생성 루프·결정성 — 재현 가능한 데이터셋

데이터셋이 재현 가능해야 디버깅·회귀·점진 개선이 된다 — Replicator의 결정성(determinism) 과 그 한계.

   생성 루프와 결정성:

   for i in range(N):                         # trigger.on_frame(N)이 실행되는 루프
       randomize(seed_for_frame_i)            # 시드 기반 무작위 → 재현 가능
       render()                               # RTX 렌더
       capture_annotators()                   # GT 추출
       write(frame_i)                         # 디스크 기록

   결정성:
     · 시드(seed) 고정 → 같은 씬·시드 = 같은 데이터셋(재현)
     · 디버깅·회귀(데이터 변경 영향)·점진 개선·팀 공유에 필수
   한계(정직, 9.11):
     · GPU 병렬·부동소수·RTX 비결정으로 비트 단위 완전 재현은 어려울 수 있음
     · 시드로 "통계적·구조적 재현"은 되나 픽셀 단위 동일은 보장 못 할 수

• 시드(seed)로 재현: 랜덤화는 시드 기반 의사난수 — 같은 시드면 같은 변형 시퀀스(프레임 i의 자산 위치·색·조명이 동일) → 같은 데이터셋. 이것이 ① 디버깅(비정상적인 프레임 재현) ② 회귀(랜덤화·자산 변경이 데이터에 미친 영향 비교) ③ 점진 개선(같은 베이스에 변형 추가) ④ 팀 공유(같은 스크립트=같은 데이터)에 필수.
• 결정성의 가치: "이 모델이 왜 이 장면서 실패?"를 그 프레임을 재현해 분석하고(8.14 데이터 엔진), 랜덤화 범위를 바꿨을 때 데이터가 어떻게 달라지나를 통제 비교. 재현 없는 데이터 생성은 디버깅·개선이 어렵다.
• GPU 비결정 한계(정직, 9.11): GPU 병렬·부동소수·RTX 렌더(샘플링·디노이징)의 비결정으로 비트 단위 완전 재현은 어려울 수 있다 — 시드로 랜덤화 시퀀스(구조)는 재현되나 렌더 픽셀이 미세하게 다를 수. "통계적·구조적 재현"은 되되 픽셀 동일은 보장 못 함. 학습엔 보통 충분(통계적 재현이면 OK).
• 오프라인 배치(9.11·9.12): 생성은 실시간이 아니어도 된다 — 헤드리스 배치로 오프라인에서 품질(패스트레이싱 10.2)·대량. 실시간성 대신 충실도·규모.

견해: 생성 루프는 시드 기반 randomize→render→capture→write의 반복이고, 시드 고정으로 재현 가능한 데이터셋을 만든다 — 디버깅·회귀·점진 개선·팀 공유의 토대. 단 GPU·RTX 비결정으로 비트 단위 완전 재현은 어려울 수(통계적·구조적 재현은 됨). 생성은 오프라인 배치라 실시간 대신 충실도·규모에 투자. 재현성이 데이터 엔진(8.14)의 통제를 준다.

10.5.6 스케일 — 헤드리스·멀티 GPU·클라우드

합성데이터의 힘은 규모 — 수만~수백만 장을 생성해야 의미가 있다. Replicator의 스케일 메커니즘.

   대량 생성 스케일:

   헤드리스(10.1)  — UI 없는 Kit 앱으로 서버·배치(GUI 오버헤드 0)
   멀티 GPU          — 렌더·생성을 여러 GPU로 분산(10.2)
   클라우드(OVX)·팜  — 여러 노드로 병렬 배치 → 수백만 장
   분산 분할         — N장을 노드·GPU로 나눠(예: 시드 범위 분할) 병렬

   처리량·비용(개략, 환경 의존):
     · 프레임당 렌더 비용 = 해상도·샘플(패스트레이싱 10.2)·씬 복잡도
     · 실시간 모드(빠름·품질↓) vs 패스트레이싱(느림·갭↓) 선택(10.2)
     · 대량은 GPU 시간·스토리지 비용 → 처리량↔품질↔비용 균형

• 헤드리스 배치(10.1): 생성은 headless Kit 앱으로 — GUI 없이 서버·클라우드에서. UI가 확장이라 빼면 그만(10.1.5). 수만 장을 무인 배치.
• 멀티 GPU·클라우드(OVX)·렌더팜: 렌더·생성을 여러 GPU·노드로 분산해 처리량↑. 데이터셋을 시드 범위·씬 변형으로 분할해 노드별 병렬 생성(예: 노드 1은 시드 0~10000, 노드 2는 10001~20000) → 합치면 한 데이터셋. 수백만 장도 며칠에.
• 처리량↔품질↔비용 균형(10.2): 프레임당 비용은 해상도·렌더 샘플(패스트레이싱은 비쌈)·씬 복잡도로 결정. 실시간 모드(빠름·약간의 갭)와 패스트레이싱(느림·갭 작음)을 데이터 용도로 선택(10.2) — 대량·약간 갭 허용이면 실시간, 정확·소량이면 패스트레이싱. GPU 시간·스토리지 비용을 고려.
• 스토리지·관리: 수백만 장 + 라벨은 테라바이트 — 스토리지·데이터 관리·중복 제거(6.6 정신)·버전. 맹목적 증량이 아니라 다양성·품질이 중요(10.6).
• 결정적 분할(10.5.5): 시드 기반이라 분산 노드가 겹치지 않는 시드 범위로 생성하면 중복 없이 병렬·재현.

견해: 합성데이터의 힘은 규모이고, Replicator는 헤드리스(10.1)·멀티 GPU·클라우드(OVX)·분산 분할로 수만~수백만 장을 생성한다. 시드 범위로 노드를 나눠 중복 없이 병렬. 처리량↔품질↔비용은 RTX 모드(실시간 vs 패스트레이싱 10.2)·해상도·복잡도로 균형 — 대량·약간 갭이면 실시간, 정확이면 패스트레이싱. 맹목적 증량보다 다양성·품질(10.6)이 핵심.

10.5.7 워크스루 — 데이터셋 한 배치·학습 연결

생성 파이프라인을 코드로 작성하고 학습에 연결하는 흐름(개념 골격, 심화 랜덤화·annotator는 10.6).

# Replicator 데이터셋 생성(개념 — API는 릴리스 의존, 반드시 확인)
import omni.replicator.core as rep

# ① 씬·자산(USD 10.3) — 카메라, 라이트, 대상 자산(의미 라벨)
camera = rep.create.camera(position=(0, 0, 3), look_at=(0, 0, 0))
render_product = rep.create.render_product(camera, resolution=(1024, 1024))
# 대상 자산을 reference로(10.4) + 의미 라벨
target = rep.create.from_usd("./assets/part.usd", semantics=[("class", "part")])
distractors = rep.create.from_usd("./assets/clutter.usd")   # 방해물

# ② randomizer + ③ trigger — 매 프레임 변형(개요, 전략은 10.6)
with rep.trigger.on_frame(num_frames=10000):                 # 1만 장 생성
    with target:
        rep.modify.pose(position=rep.distribution.uniform((-1,-1,0),(1,1,0)),
                        rotation=rep.distribution.uniform((0,0,0),(360,360,360)))
    rep.randomizer.materials(...)        # 재질·색(10.6)
    rep.randomizer.lights(intensity=rep.distribution.uniform(300, 2000))
    rep.randomizer.camera(...)           # 시점

# ⑤ annotator + ⑥ writer — GT(개요, 종류 심화 10.6) → 디스크
writer = rep.WriterRegistry.get("KittiWriter")   # 또는 BasicWriter/COCO/커스텀
writer.initialize(output_dir="/data/synth_part",
                  rgb=True, bounding_box_2d_tight=True,
                  semantic_segmentation=True, instance_segmentation=True,
                  distance_to_camera=True)        # 깊이
writer.attach([render_product])

# ④ render는 trigger 루프가 자동 — 실행
rep.orchestrator.run()    # 1만 장: 매번 랜덤화→렌더→GT 캡처→디스크

# 헤드리스 대량 실행(10.1·10.5.6)
./kit replicator_app.kit --no-window --/omni/replicator/script=gen.py   # 개념
#   · 멀티 GPU·클라우드(OVX)로 분산, 시드 범위 분할(10.5.6)

# 학습 연결: 생성 데이터로 인지 모델 학습 → 배포
#   · TAO Toolkit / PyTorch / NeMo가 KITTI·COCO 데이터셋 소비
#   · 학습 → TensorRT(5.2) → 엣지(9.1) → 검증(SIL 9.12)

   체크포인트:
     · 출력에 이미지 + 라벨(박스·마스크·깊이)이 정확히 정렬되나(10.6에서 검증)
     · 1만 장이 충분히 다양한가(랜덤화 — 10.6 전략)
     · 포맷(KITTI/COCO)이 학습 파이프라인과 맞나
     · 시드 고정으로 재현되나(10.5.5) → 회귀·디버깅
     · 헤드리스·멀티 GPU로 처리량 나오나(10.5.6)

• 학습 연결(데이터 엔진): 생성 데이터셋을 TAO Toolkit·PyTorch·NeMo가 소비해 인지 모델(검출·분할 9.7~9.9) 학습 → TensorRT(5.2) 최적화 → 엣지 배포(9.1) → SIL(9.12)·실로봇 검증. 합성데이터가 인지 파이프라인의 연료.
• 데이터 플라이휠(8.14·7.7·9.12): 생성 → 학습 → 배포 → 실패 케이스 발견 → 그 조건(자산·시점·조명)을 랜덤화·씬에 반영해 타깃 재생성 → 재학습. 시뮬이 결정적·타깃 데이터를 무한 공급하니 플라이휠이 빠르다.
• 혼합(정직): 합성만으론 갭(10.7) → 합성 + 실데이터 혼합이 보통 최선. 합성으로 규모·롱테일·완벽 라벨을, 실로 실제 분포를.

견해: 실습은 씬(USD)·자산(reference·의미 라벨)·randomizer·trigger(N장)·annotator(GT)·writer(포맷) 를 코드로 작성하고 orchestrator.run()으로 생성하는 것 — 헤드리스·멀티 GPU로 대량(10.5.6). 생성 데이터는 TAO·PyTorch로 학습→TensorRT(5.2)→엣지→검증(9.12), 실패를 타깃 재생성하는 플라이휠(8.14). 합성+실 혼합이 최선. 랜덤화 전략·annotator 종류의 심화는 10.6.

10.5.8 중간 점검 (체크포인트)

• [ ] 인지의 병목이 라벨 데이터이고, 실라벨링의 한계(비용·노이즈·롱테일·불가능 GT)와 합성의 답·한계(Sim2Real)를 안다.
• [ ] Replicator가 Kit(10.1)·USD(10.3)·RTX(10.2) 위의 SDG 프레임워크이고 Python·헤드리스임을 안다.
• [ ] 생성 파이프라인(씬→randomizer→trigger→render→annotator→writer)의 컴포넌트·흐름을 안다.
• [ ] 시드로 재현 가능한 데이터셋과 GPU·RTX 비결정 한계(통계적 재현)를 안다.
• [ ] 헤드리스·멀티 GPU·클라우드·시드 분할로 대량 생성하고 처리량↔품질↔비용을 균형함을 안다.
• [ ] 생성 데이터를 TAO·PyTorch 학습→TensorRT(5.2)→엣지→검증 연결하고 플라이휠(8.14) 을 돎을 안다.

증상→의심: 모델이 실세계서 취약 → 합성만 학습·랜덤화 부족 → DR(10.6)·실혼합(10.7). 라벨이 이미지와 어긋남 → annotator 정렬·좌표·writer(10.6에서 검증). 데이터 다양성 부족 → randomizer 범위·자산(10.6). 재현 안 됨 → 시드 미고정·GPU 비결정 한계 → 시드·통계적 재현(10.5.5). 생성이 느림 → 패스트레이싱·고해상도·단일 GPU → 실시간 모드·멀티 GPU·헤드리스(10.2·10.5.6). 포맷 불일치 → writer 포맷 ≠ 학습 파이프라인 → KITTI/COCO/커스텀 정합. 스토리지 폭증 → 맹목적 대량 → 다양성·품질 우선(10.6). Jetson서 생성 시도 → RTX 워크스테이션/OVX(9.11).

10.5.9 트레이드오프·대안

견해: 데이터가 병목인 인지(특히 깊이·3D·롱테일·균형이 필요한)는 합성데이터가 강력하고, Replicator는 RTX 충실도·정밀 멀티 GT·USD·스케일로 그 공장이 된다. 단 합성만으론 Sim2Real 갭(10.7) 이 남아 합성+실 혼합이 보통 최선 — 합성으로 규모·롱테일·완벽 라벨, 실로 실제 분포. 다양성(랜덤화 10.6)이 양보다 중요(같은 1만 장도 다양해야 일반화). 결정성(시드) 으로 회귀·디버깅. 처리량↔품질은 RTX 모드(10.2). 효과는 과제 의존이라 실데이터로 검증(시뮬 성공≠실세계).

비엔비디아 정직: 합성데이터·SDG는 NVIDIA만의 것이 아니다 — Unity Perception·Unreal 기반 SDG·BlenderProc·Kubric·NVISII 등 다양한 도구가 있고, 학계·업계가 합성데이터를 널리 연구한다(자율주행·로봇·의료). Replicator/Omniverse의 강점은 RTX 실시간 레이트레이싱(갭 작은 데이터)·OpenUSD 자산·정밀 멀티 GT(분할·3D 박스·깊이·법선·amodal 동시)·대규모 GPU/클라우드·Isaac/TAO 통합이다. 게임 자산·친숙함이면 Unity/Unreal SDG가, 경량·연구면 BlenderProc가 나을 수 있다 — 포토리얼·정밀 멀티 GT·USD·NVIDIA 스택이 핵심이면 Replicator. 합성데이터 효과는 과제·랜덤화·혼합 의존이라 자기 과제에서 검증.

10.5.10 흔한 함정

• 합성만으로 학습. Sim2Real 갭으로 실세계 취약 → 도메인 랜덤화(10.6)·실데이터 혼합(10.7).
• 다양성 없이 대량. 같은 장면 1만 장은 1장과 다름없음 → 랜덤화로 다양성(10.6), 양보다 다양성.
• 시드 미고정. 재현·회귀 불가 → 시드 고정(통계적 재현 10.5.5).
• 지나치게 이상적인 데이터. 센서 노이즈 없으면 실세계 취약 → 노이즈·왜곡(9.11·10.6).
• 패스트레이싱으로 맹목적 대량. 느리고 비쌈 → 용도에 맞게 실시간/패스트레이싱(10.2·10.5.6).
• 라벨·이미지 정렬 안 검증. 마스크·박스가 어긋남 → 시각 검증(10.6).
• 단일 GPU·GUI로 대량. 느림 → 헤드리스·멀티 GPU·클라우드(10.1·10.5.6).
• 포맷 불일치. writer ≠ 학습 파이프라인 → KITTI/COCO/커스텀 정합.
• 스토리지·관리 무시. 수백만 장 TB → 스토리지·중복 제거·버전(6.6 정신).
• 시뮬 성공을 실세계로 단정. 합성 효과는 검증 필요 → 실데이터·실환경 검증(10.7).

10.5.11 연습문제

연습 1 (왜 합성). 인지의 병목이 왜 라벨 데이터이고 실라벨링의 한계가 무엇인지 들고, 합성데이터가 푸는 네 가지와 그 한계를 답하라.

연습 2 (파이프라인 컴포넌트). Replicator 생성 파이프라인의 여섯 컴포넌트(씬·randomizer·trigger·render·annotator·writer)를 들고 각 역할과 한 프레임의 흐름을 설명하라.

연습 3 (결정성). 합성데이터 생성에서 결정성(시드)이 왜 중요한지 네 가지 용도로 설명하고, GPU·RTX 비결정의 한계가 무엇이며 그래도 왜 충분한지 답하라.

연습 4 (스케일). 100만 장 합성 데이터셋을 생성한다면 헤드리스·멀티 GPU·클라우드·시드 분할을 어떻게 쓰고, 처리량↔품질↔비용을 어떻게 균형하는지 설계하라.

연습 5 (플라이휠·혼합). 합성 데이터셋을 학습에 연결하는 흐름과 데이터 플라이휠(8.14)을 설명하고, 합성+실 혼합이 왜 보통 최선이며 각각이 무엇을 담당하는지 답하라.

10.5.12 요약 · 다음 장

• 데이터 병목 → 합성데이터: 인지의 제약 요인은 라벨 데이터(실라벨링은 비용이 크고·노이즈·롱테일 위험·불가능 GT). 합성은 완벽·자동·무한·균형·불가능 GT로 풀되 Sim2Real 갭(10.7) — DR(10.6)·실혼합 필요.
• Replicator: Kit(10.1)·USD(10.3)·RTX(10.2) 위의 SDG 프레임워크, Python·헤드리스. USD가 씬, RTX가 렌더·GT, Replicator가 오케스트레이션.
• 생성 파이프라인: 씬→randomizer→trigger→render→annotator→writer의 조립 라인, trigger가 N번 실행해 데이터셋. 각 단계 모듈(조합·교체). 랜덤화 전략·annotator 심화는 10.6.
• 결정성·스케일: 시드로 재현 가능(GPU 비결정은 통계적 재현)·디버깅·회귀. 헤드리스·멀티 GPU·클라우드·시드 분할로 대량, 처리량↔품질↔비용(RTX 모드)·다양성 우선.
• 연결: TAO·PyTorch 학습→TensorRT(5.2)→엣지→검증(9.12), 타깃 재생성 플라이휠(8.14). 합성+실 혼합이 최선. 정직: API 릴리스 의존, 효과 검증 필요, 비NVIDIA(Unity·BlenderProc), RTX GPU(엣지 아님).

다음 장: 10.6 합성데이터 II — 도메인 랜덤화·자동 라벨. 파이프라인 구조를 봤으니, 그 안의 두 핵심 — 도메인 랜덤화 전략(무엇을·얼마나·어떤 분포로 흔들어 Sim2Real을 좁히나)과 자동 라벨(annotator) 의 종류·정확성(분할·박스·깊이·amodal) — 을 실습으로 깊이 판다. 데이터 공장의 다양성과 라벨 품질로.