TrendShift 딥다이브 · 2026-07-03

NVlabs/ProtoMotions 딥다이브
— 가상의 인간·로봇에게 "움직이는 법"을 물리 시뮬레이션으로 가르치는 GPU 학습 프레임워크

ProtoMotions3NVIDIA Research가 공개한 물리 기반 휴머노이드 시뮬레이션 & 강화학습 프레임워크다. 실제 사람의 동작 데이터(AMASS, 40시간 이상)를 가상 물리 세계에서 로봇/디지털 휴먼이 직접 흉내 내도록 강화학습으로 훈련시키고, 학습된 정책을 실제 휴머노이드 로봇(Unitree G1)에 그대로 이식할 수 있다. (저장소: NVlabs/ProtoMotions · Apache-2.0 · ★1.7k · Python 99.3% · 소스 코드 약 97,000줄)
목차
  1. 프로젝트 한줄 요약
  2. 왜 주목받는가
  3. 기술 스택 전체 지도
  4. 아키텍처 심화 분석
  5. 디렉토리 구조 해부
  6. 학습 포인트 (기술별)
  7. 하드웨어 / 시스템 요구사항
  8. 직접 해볼 수 있는 실습 과제
  9. 관련 기술 심화 학습 로드맵
  10. 핵심 키워드 사전
  11. 참고 링크

1프로젝트 한줄 요약

이 저장소가 대체 무엇인가.

핵심 메시지

"사람 동작 데이터를 통째로 물리 시뮬레이션에 넣고, 로봇이 직접 몸으로 익히게 한다" — 애니메이션·로보틱스·강화학습을 한 플랫폼에서 잇는 프로토타이핑 도구.

게임 캐릭터가 자연스럽게 걷고 뛰고 구르는 애니메이션을 만들려면 전통적으로는 사람이 모션 캡처를 찍고 애니메이터가 일일이 다듬어야 했다. 로봇이 걷는 법을 배우게 하려면 로봇공학자가 제어 이론으로 보행 패턴을 손수 설계해야 했다. ProtoMotions3는 이 두 문제를 하나의 틀로 묶는다 — "물리 법칙이 작동하는 가상 세계(시뮬레이터)에 사람 동작 데이터를 놓고, 강화학습 에이전트가 그 동작을 흉내 내는 과정에서 스스로 균형·보행·제어를 익히게" 하는 것이다.

비유하면: AMASS 동작 데이터셋 = 무술 교본 영상 수만 개, 물리 시뮬레이터(IsaacGym 등) = 안전하게 반복 연습할 수 있는 가상 도장, 강화학습 에이전트 = 영상을 보고 실제로 몸을 움직여 따라 하는 연습생이다. 수천 개의 가상 도장(병렬 환경)에서 동시에 연습시키면, GPU 한 대로 하루 만에 40시간 분량의 동작을 익힐 정도로 빨라진다. 그리고 이 연습생(정책)을 실제 로봇(Unitree G1)에 그대로 옮겨 심으면, 진짜 로봇이 사람처럼 움직인다.

README는 이렇게 소개한다: "A GPU-accelerated simulation and learning framework for training physically simulated digital humans and humanoid robots." 모듈성(Modularity), 확장성(Extensibility), 확장 가능성(Scalability) 세 가지를 핵심 가치로 내세우며, 애니메이션·로보틱스·강화학습이라는 서로 다른 커뮤니티를 잇는 다리 역할을 표방한다. NVIDIA Research의 SIL(Simulation, Imitation, Learning) 팀이 만들었고, 이전 버전들(ProtoMotions, ASE, MaskedMimic 등 여러 논문 코드베이스)의 후속작인 3세대(v3.1)다.

용어
물리 기반 캐릭터 애니메이션(Physics-based Character Animation)
전통적인 애니메이션은 미리 정해진 관절 각도를 재생만 하는 키네마틱(kinematic) 방식이라, 캐릭터가 벽에 부딪히거나 밀려도 아무 반응이 없다. 물리 기반 방식은 실제 중력·관성·마찰이 작동하는 시뮬레이터 안에서 관절에 토크(힘)를 가해 캐릭터를 움직인다 — 밀치면 휘청이고, 넘어지면 실제로 쓰러진다. ProtoMotions는 강화학습으로 "이 토크를 어떻게 가해야 목표 동작을 따라 하면서도 안 넘어지는지"를 학습시킨다.

2왜 주목받는가

NVIDIA Research의 다목적 통합 플랫폼 포지셔닝 · sim2real 실증 · 경쟁 프로젝트 대비 장점.

ProtoMotions3가 TrendShift 상위권에 오른 이유는 크게 세 가지로 요약된다. 첫째, 휴머노이드 로봇(Unitree G1·H1_2 등) 상용화가 급물살을 타면서 "물리 시뮬레이션으로 로봇 제어를 학습시키는" 접근 자체의 수요가 폭증했다. 둘째, README가 보여주는 데모 목록이 이례적으로 광범위하다 — 대규모 모션 학습, 멀티 GPU 확장, 원커맨드 리타겟팅, 임의 로봇 학습, sim2sim, sim2real, 고품질 렌더링, 텍스트-투-모션, 절차적 씬 생성, 생성형 정책까지 한 저장소 안에서 전부 다룬다. 셋째, NVIDIA Research 브랜드와 Apache-2.0 완전 오픈소스 라이선스가 결합되어 학계·산업계 양쪽에서 채택 장벽이 낮다.

경쟁/유사 프로젝트 대비 무엇이 다른가

비교 축IsaacLab / legged_gymASE / AMP (원조 논문 코드)ProtoMotions3의 접근
범위범용 로봇 학습 프레임워크(과제 특화 X)단일 논문 재현용 코드(범위 좁음)모션 모방 + 로보틱스 + 생성형 정책을 한 저장소에
시뮬레이터보통 1~2종 고정IsaacGym 단일 종속5종 지원(IsaacGym/IsaacLab/Newton/MuJoCo/Genesis) — 실행 인자 한 줄만 교체
모션 데이터제공 안 함(직접 설계)AMASS 일부AMASS 전체(40+시간) + BONES-SEED(14만+ 모션) + Kimodo 텍스트-투-모션
로봇 확장로봇별 재구현 필요SMPL 휴머노이드 고정설정 파일 등록만으로 신규 로봇 추가(robot_configs/factory.py)
sim2real 실증제한적없음(순수 시뮬레이션 연구)Unitree G1 실기 배포 + ONNX 파이프라인 문서화
자매 프로젝트--MimicKit(경량 버전) 병행 제공
주목 포인트 — "말로만 통합"이 아니라 코드로 증명된 멀티 시뮬레이터
--simulator=isaacgym → --simulator=newton → --simulator=mujoco, 인자 하나로 물리 엔진 교체

README는 "One-click test of robot control policies... in different physics engines"라고 주장하는데, 실제로 protomotions/simulator/ 아래에 base_simulator/(추상 인터페이스)와 isaacgym/·isaaclab/·newton/·mujoco/·genesis/ 5개의 구체 구현이 나란히 존재한다. base_simulator/simulator.py(1,679줄)에 정의된 추상 메서드가 20개 이상(_physics_step·_apply_simulator_pd_targets·_get_simulator_bodies_state 등)이며, 각 시뮬레이터는 이 계약을 구현하기만 하면 나머지 학습·평가·리타겟팅 코드를 그대로 재사용한다. "말로만 5종 지원"이 아니라 실제 추상 클래스 설계로 뒷받침된 통합이다.

주목 포인트 — Sim2Real을 위한 전용 ONNX 배포 파이프라인
observation 계산까지 통째로 굽는 "단일 ONNX 모델" 전략

README는 이렇게 설명한다: "Our deployment pipeline exports a single ONNX model (with observation computation baked in), so deployment frameworks only need to provide raw sensor signals." 실제로 deployment/export_bm_tracker_onnx.py(740줄)는 체크포인트에서 관측(observation) 함수까지 통째로 ONNX 그래프에 굽는다 — 로봇 배포 팀이 별도로 "학습 때와 똑같은 관측 계산 로직"을 재구현할 필요가 없다는 뜻이다. 이런 실무 디테일까지 오픈소스로 공개된 점이 로보틱스 실무자들에게 특히 매력적이다.

기대치 조정 — 연구용 프로토타입이지 프로덕션 로봇 SDK가 아니다
GPU 다중 장착이 사실상 전제, 진입 장벽은 여전히 높다

이름 그대로 "프로토타이핑 플랫폼"이다. README의 대표 데모(AMASS 전체 학습)는 A100 4장으로 12시간, 대규모 확장 실험은 A100 24장을 사용했다고 명시되어 있다 — 개인이 노트북에서 대표 결과를 그대로 재현하기는 어렵다. 다만 MuJoCo 백엔드는 CPU 전용(num_envs=1)으로 동작해, 학습된 체크포인트를 GPU 없이 눈으로 확인하는 용도로는 쓸 수 있다(7·8절 참고).

3기술 스택 전체 지도

시뮬레이터 백엔드 5종 · 강화학습 프레임워크(PyTorch Lightning Fabric) · 리타겟팅/변환 파이프라인.

setup.py는 아주 단순하다 — 패키지 이름 protomotions, 버전 3.1, find_namespace_packages로 하위 패키지를 전부 포함한다. 진짜 복잡함은 의존성 쪽에 있다 — 시뮬레이터별로 requirements_isaacgym.txt·requirements_isaaclab.txt·requirements_newton.txt·requirements_mujoco.txt·requirements_genesis.txt 5개의 별도 requirements 파일이 존재한다. 이는 "하나의 코드베이스, 여러 개의 설치 프로파일"이라는 설계 철학을 그대로 드러낸다.

백엔드별 시뮬레이터 스택

시뮬레이터실행 방식핵심 의존성특징
IsaacGymPreview 4, GPU 전용torch>=2.2, python 3.8가장 오래된 대규모 병렬 GPU 물리 엔진. 레거시지만 여전히 널리 쓰임
IsaacLabv2.3.0, GPU 전용Omniverse 기반, USD 씬IsaacGym 후속. Gaussian splatting 렌더링(IsaacSim 5.0+) 지원
Newton1.0.0(PyPI), GPU 전용warp-lang, mujoco 3.5.0, uv 패키지 매니저NVIDIA·Google DeepMind·Disney Research 공동 개발 차세대 오픈 물리 엔진
MuJoCo3.0+, CPU 전용onnxruntime, dm_control단일 환경(num_envs=1)만 지원 — 빠른 디버깅·재현용
Genesis커뮤니티 기여, 미검증(untested)genesis-world, torch==2.5.0공식 지원은 아니나 "커스텀 시뮬레이터 추가" 예시로 저장소에 포함

학습/에이전트 스택

레이어기술역할
분산학습 오케스트레이션PyTorch Lightning Fabric멀티 GPU/노드 학습 루프 관리(fabric.launch()·fabric.call() 훅 시스템)
실험 추적Weights & Biases(wandb) + TensorBoard학습 곡선·하이퍼파라미터 로깅. wandb 비활성 시 자동 폴백
텐서 배치 관리tensordict관측/보상/종료 신호를 named-tensor 딕셔너리로 일괄 처리
SLURM 통합train_slurm.py + callbacks/slurm_autoresume_srun.py클러스터 큐 시스템에서 자동 재시작(auto-resume) 지원
물리 자세 라이브러리pose_lib(protomotions/components)SMPL/SMPL-X/MJCF 골격 파싱, 순기구학(FK) 계산
리타겟팅 엔진PyRoki(chungmin99/pyroki)사람 동작 → 로봇 관절각으로 최적화 기반 변환(구 버전은 Mink 사용)
모델 로딩transformers(>=4.20)MaskedMimic 등 트랜스포머 기반 정책의 백본
구성 관리자체 config_builder(Hydra 유사, 순정 dataclass)실험 파일이 함수로 config를 조립 — YAML 대신 Python 코드로 설정
ONNX 배포onnxruntime학습된 정책 + 관측 계산을 통째로 그래프로 굽는 배포 표준 포맷
USD 변환usd_convert/ 스크립트 모음MJCF(MuJoCo XML) ↔ USD(Universal Scene Description) 상호 변환
테스트pytest100개 이상의 테스트 파일 — 회귀 방지용 유닛 테스트가 매우 촘촘함
용어
AMASS (Archive of Motion Capture as Surface Shapes)
전 세계 여러 모션 캡처 데이터셋을 SMPL이라는 통일된 사람 3D 모델 표준으로 정리해 놓은 대규모 공개 데이터셋이다. "다양한 실제 사람 동작을 한 포맷으로 모아 놓은 교본"이라 생각하면 된다. ProtoMotions는 이 40시간 이상 분량의 동작을 통째로 학습 데이터로 사용한다.
용어
USD (Universal Scene Description)
픽사(Pixar)가 만들고 NVIDIA Omniverse가 채택한 3D 장면 교환 포맷이다. 여러 소프트웨어(블렌더·마야·Isaac Sim 등) 사이에서 3D 씬·재질·물리 속성을 손실 없이 주고받기 위한 표준으로, 게임 엔진의 "만능 씬 파일 포맷"에 가깝다. ProtoMotions는 로봇 MJCF 모델을 USD로 변환해 고품질 렌더링(IsaacSim)에 사용한다.

4아키텍처 심화 분석

멀티 시뮬레이터 추상화 · MdpComponent 모듈 조립 · obs/reward/control 분리 · 학습 루프 전체 흐름.

ProtoMotions3의 아키텍처를 이해하는 가장 빠른 길은 "이 저장소가 어떤 문제를 풀려고 이렇게 설계됐는가"를 먼저 보는 것이다. 목표는 물리 엔진이 바뀌어도 학습 코드는 그대로, 새로운 과제(steering·mimic·masked_mimic 등)를 만들 때 거대한 환경 클래스를 통째로 새로 짜지 않아도 되게, 학습된 정책을 ONNX로 내보낼 때 "이 관측값이 어디서 왔는지"를 자동으로 추적할 수 있게 하는 것이다. 이 세 목표가 각각 Simulator 추상 클래스, MdpComponent 컴포넌트 시스템, FieldPath 컨텍스트 경로라는 세 가지 설계로 구현되어 있다.

사용자 실험 파일 (examples/experiments/steering/mlp.py) │ terrain_config() / motion_lib_config() / env_config() / agent_config() ▼ ┌──────────────────────────────────────────────────────────────────┐ │ train_agent.py — 학습 오케스트레이터 │ │ ① configure_robot_and_simulator() │ │ ② env_config() → EnvConfig (observation/reward/control 컴포넌트) │ │ ③ agent_config() → PPOAgentConfig / AMPAgentConfig 등 │ │ ④ build_all_components() → terrain/scene_lib/motion_lib/simulator│ └───────────────┬────────────────────────────────┬───────────────────┘ │ │ ▼ ▼ ┌─────────────────────────┐ ┌─────────────────────────────┐ │ BaseEnv (env.py) │ │ Simulator (abstract, 20+ 메서드)│ │ ComponentManager로 │◀──────▶│ ┌─────────┬─────────┬────────┐│ │ MdpComponent 실행 │ state │ │IsaacGym │IsaacLab │ Newton ││ │ (obs/reward/termination) │ action │ │ Preview4│ v2.3.0 │ 1.0.0 ││ └───────────┬───────────────┘ │ ├─────────┼─────────┤ ││ │ obs 딕셔너리 │ │ MuJoCo │ Genesis │ ││ ▼ (max_coords_obs, ...) │ │(CPU전용)│(커뮤니티)│ ││ ┌─────────────────────────┐ │ └─────────┴─────────┴────────┘│ │ BaseAgent (PPO/AMP/...) │ └─────────────────────────────┘ │ Lightning Fabric로 분산 │ │ actor/critic 순전파·역전파 │ └───────────┬───────────────┘ │ action (PD target 또는 torque) ▼ Simulator._apply_simulator_pd_targets() │ ▼ (물리 스텝) 다음 obs로 순환 ──────────────────────┘ 배포 시: 체크포인트 → export_bm_tracker_onnx.py → unified_pipeline.onnx (MdpComponent의 FieldPath가 그대로 ONNX 입력 이름이 됨)

① Simulator 추상 클래스 — "20개 이상의 계약"으로 시뮬레이터를 갈아 끼운다

protomotions/simulator/base_simulator/simulator.py(1,679줄)는 Simulator(RecordingMixin, ABC)라는 추상 클래스를 정의한다. _physics_step·_apply_simulator_pd_targets·_apply_simulator_torques·_get_simulator_bodies_state·_get_sim_body_ordering@abstractmethod로 표시된 메서드가 20개 이상이며, 각 물리 엔진 구현체(isaacgym/simulator.py·newton/simulator.py 등)는 이 메서드들만 자신의 API에 맞게 구현하면 된다. 그 위의 공개 API(reset()·step()·get_bodies_state())는 전부 부모 클래스에 한 번만 구현되어 있어, 학습 루프·리타겟팅·평가 코드는 어떤 시뮬레이터를 쓰든 완전히 동일하다.

이런 상황을 상상해봐

자동차 회사가 엔진 제조사(현대·도요타·테슬라)를 자유롭게 바꿔 끼울 수 있게 하려면, "가속 페달을 밟으면 바퀴가 굴러간다"는 겉모습(운전자 인터페이스)은 그대로 두고, 내부에서 "페달 신호를 받아 실제로 엔진을 돌리는" 부분만 각 제조사가 자기 방식대로 구현하게 한다. Simulator 추상 클래스가 정확히 이 역할이다 — _physics_step() 하나가 "엔진을 실제로 돌리는" 부분이고, IsaacGym·Newton·MuJoCo가 각자 다른 방식으로 이 페달을 밟는다.

② MdpComponent — "관측/보상/종료 함수 + 데이터 출처"를 하나로 묶는다

실제 소스(protomotions/envs/mdp_component.py)를 열어 보면, MdpComponent 클래스는 세 부분으로 나뉜다: compute_func(순수 텐서 함수 — 부작용 없이 입력을 받아 출력을 계산), dynamic_vars(compute_func의 파라미터 이름을 FieldPath 객체에 매핑 — "이 값은 매 스텝 바뀐다"는 뜻), static_params(가중치·상수처럼 실행 중 안 바뀌는 값). 이 구조가 왜 중요한가는 get_bindings_dict() 메서드를 보면 드러난다 — dynamic_vars의 FieldPath들이 그대로 ONNX 입력 이름 문자열로 변환된다. 즉 "이 관측값이 컨텍스트의 어느 경로에서 왔는지"를 설정 단계에서부터 명시적으로 선언해 두면, 나중에 배포 파이프라인이 자동으로 "로봇이 실제로 어떤 센서 데이터를 넣어줘야 하는지"를 추출할 수 있다.

# mdp_component.py 실제 docstring 예제 (경로 표기 + 정적 파라미터 분리)
observation_components = {
    "max_coords_obs": MdpComponent(
        compute_func=compute_humanoid_max_coords_observations,
        dynamic_vars={
            "body_pos": EnvContext.current.rigid_body_pos,  # FieldPath
            "body_rot": EnvContext.current.rigid_body_rot,
        },
        static_params={"local_obs": True},  # ONNX 그래프에 상수로 굽힘
    ),
}

context_views.pyEnvContext클래스 레벨로 접근하면(EnvContext.current.dof_pos) 설정용 FieldPath 객체를 반환하고, 인스턴스 레벨로 접근하면(ctx.current.dof_pos) 실제 텐서 값을 반환하는 이중 접근(dual access) 디스크립터 패턴을 쓴다. 이 트릭 덕분에 실험 config 파일 안에서 IDE 자동완성을 받으면서도, 런타임에는 진짜 텐서가 흘러 들어온다.

③ 관측/보상/제어의 3단 분리 — steering 과제로 보는 실전 조립

README가 자랑하는 "몬리식 env 클래스 없이 모듈로 과제를 조립한다"는 주장은 실제로 steering(방향 조종) 과제의 4개 파일에서 그대로 확인된다.

레이어실제 파일역할
Controlenvs/control/steering_control.py과제 상태(목표 방향·속도·바라보는 방향) 관리. 주기적으로 새 목표를 샘플링
Observationenvs/obs/steering.py순수 텐서 커널 — 목표를 로봇 로컬 좌표계로 변환해 5차원 특징 벡터로
Rewardenvs/rewards/task.pycompute_heading_velocity_rew — 방향 일치(0.7) + 자세 일치(0.3) 보상 혼합
Experimentexamples/experiments/steering/mlp.py위 세 조각을 MdpComponent 인스턴스로 엮어 하나의 학습 설정으로 완성

실제 steering_control.py(약 220줄)를 열어 보면, SteeringControl 클래스는 reset()(새 목표 방향·속도 샘플링, 10%는 완전 랜덤 방향, 나머지는 이전 방향에서 점진적 변화), step()(목표 갱신 시점 확인), populate_context()(계산된 상태를 EnvContext.steering에 채워 넣기)라는 세 메서드만으로 과제 상태 관리를 전부 해결한다. 이 클래스는 관측·보상 계산 로직을 전혀 모른다 — 오직 "지금 목표가 무엇인지"만 컨텍스트에 올려 두고, 그걸 누가 어떻게 쓰는지는 mlp.pyMdpComponent로 배선한다. 이게 바로 "몬리식 env 클래스가 필요 없다"는 주장의 실체다.

④ 학습 루프 — Lightning Fabric 기반 PPO/AMP 순환

train_agent.py(1,020줄)의 main()은 체크포인트 유무로 resume/warm_start/fresh 세 모드를 판별한 뒤, build_all_components()로 terrain·scene_lib·motion_lib·simulator를 만들고, BaseEnvBaseAgent(PPO/AMP/ASE 등)를 초기화해 agent.fit()을 호출한다. 흥미로운 점은 설정 저장 방식이다 — dataclass 기반 config 객체는 JSON/YAML로 안전하게 직렬화하기 어려운 타입(Union, 중첩 dataclass, torch.Tensor)을 담고 있어서, resolved_configs.pt(pickle, 완전 재현 보장)와 resolved_configs.yaml(사람이 읽기용, best-effort)을 동시에 저장한다. "학습 중 CLI로 오버라이드한 값은 영구적으로 저장되어 재시작 시에도 그대로 적용된다"는 점도 코드 주석에 명시적으로 경고되어 있다 — 실무에서 재현성 버그를 막기 위한 설계다.

5디렉토리 구조 해부

protomotions/·examples/·pyroki/·deployment/·usd_convert/ 실제 내용 기반.

ProtoMotions/ ├── protomotions/ # 핵심 패키지 (약 97,000줄) │ ├── train_agent.py # 학습 진입점 (1,020줄) — resume/warm_start/fresh 모드 │ ├── inference_agent.py # 추론/시각화 진입점 (468줄) — 키보드 컨트롤 지원 │ ├── train_slurm.py # SLURM 클러스터 제출 스크립트 │ │ │ ├── agents/ # 강화학습 알고리즘 구현체 │ │ ├── ppo/ # PPOAgent — 기본 강화학습(agent.py 863줄) │ │ ├── amp/ # Adversarial Motion Priors — 판별기 기반 자연스러움 보상 │ │ ├── ase/ # ASE — 잠재 공간 기반 다양한 스킬 학습 │ │ ├── mimic/agent_add.py # ADD 알고리즘 — AMP를 상속해 ~100줄로 구현 │ │ ├── peft/ # PEFT — 동결된 프라이어 + 어댑터로 신규 과제 파인튜닝 │ │ ├── supervised/ # MaskedMimic — 지도학습 기반 생성형 정책 │ │ ├── fine_tuning/ # 사전학습 모듈 파인튜닝 유틸 │ │ ├── evaluators/ # 정량 평가 지표(추적 오차·부드러움 등) │ │ ├── optimizer/muon.py # Muon 옵티마이저(최신 연구 옵티마이저) 지원 │ │ └── common/ # MLP/Transformer/이산 잠재변수 등 공용 신경망 블록 │ │ │ ├── envs/ # 환경(MDP) 구성 요소 — obs/reward/control 3단 분리 │ │ ├── mdp_component.py # MdpComponent — compute_func + FieldPath 바인딩 │ │ ├── context_views.py # EnvContext — 클래스/인스턴스 이중 접근 디스크립터 │ │ ├── context_paths.py # FieldPath/NestedField/resolve_path 저수준 구현 │ │ ├── component_manager.py # MdpComponent 실행 + torch.compile 캐싱 │ │ ├── component_factories.py # 자주 쓰는 MdpComponent 조합 팩토리(1,558줄) │ │ ├── control/ # steering/mimic/masked_mimic/path_follower 등 과제별 상태 관리 │ │ ├── obs/ # humanoid/steering/target_poses/terrain 등 관측 커널 │ │ ├── rewards/ # task/tracking/regularization 보상 커널 │ │ ├── terminations/ # 과제/추적 실패 종료 조건 │ │ ├── motion_manager/ # 모션 재생 시점·ID 관리 │ │ └── base_env/env.py # BaseEnv — 전체 오케스트레이션 (1,619줄 ★최대) │ │ │ ├── simulator/ # 멀티 시뮬레이터 추상화 계층 │ │ ├── base_simulator/simulator.py # Simulator 추상 클래스 (1,679줄, 20+ 추상 메서드) │ │ ├── isaacgym/ · isaaclab/ # NVIDIA GPU 물리 엔진 2종 │ │ ├── newton/ # 차세대 오픈 물리 엔진(warp-lang 기반) │ │ ├── mujoco/ # CPU 전용, num_envs=1 — 디버깅/재현용 │ │ └── genesis/ # 커뮤니티 기여 예시 구현 │ │ │ ├── robot_configs/ # 로봇별 설정(관절 한계·PD 게인·자산 경로) │ │ ├── factory.py # robot_config(name) 팩토리 — 문자열로 로봇 선택 │ │ ├── g1.py · h1_2.py # Unitree G1/H1_2 인간형 로봇 │ │ └── smpl.py · smplx.py · soma23.py · rigv1.py # 디지털 휴먼 골격 │ │ │ ├── components/ # pose_lib(FK)·scene_lib(오브젝트)·motion_lib(모션 재생)·terrains │ ├── data/assets/ # mjcf/urdf/usd 로봇 3D 자산 │ ├── utils/ # rotations·config_builder·hydra_replacement 등 공용 유틸 │ └── tests/ # pytest 100개 이상 — 회귀 방지용 촘촘한 유닛 테스트 │ ├── examples/ │ ├── experiments/ # 실행 가능한 실험 설정 — add/amp/ase/gpc/masked_mimic/mimic/path_follower/steering │ ├── tutorial/ # 단계별 튜토리얼 스크립트 │ ├── benchmark/ # 성능 벤치마크 설정 │ └── data/ # 소규모 샘플 모션(vaulting 등) — 빠른 실습용 │ ├── pyroki/ # PyRoki 기반 대량 리타겟팅 스크립트 │ ├── batch_retarget_to_g1_from_keypoints.py # AMASS → G1 관절각 일괄 변환 (1,257줄) │ └── batch_retarget_to_h1_2_from_keypoints.py # AMASS → H1_2 관절각 일괄 변환 │ ├── deployment/ # sim2real 배포 파이프라인 │ ├── export_bm_tracker_onnx.py # 정책 + 관측 계산을 통째로 ONNX로 굽는 스크립트 (740줄) │ ├── test_tracker_mujoco.py # MuJoCo에서 배포 전 sim2sim 검증 (864줄) │ ├── motion_utils.py · state_utils.py # 배포용 모션/상태 변환 헬퍼 │ ├── usd_convert/ # MJCF ↔ USD 변환 도구 모음(5개 스크립트) ├── scripts/ # retarget_amass_to_robot.sh·smoke_test.sh 등 운영 스크립트 ├── docs/source/ # Sphinx 문서 소스 — API 레퍼런스 자동 생성 ├── legal/ # 서드파티 소프트웨어/자산 라이선스 고지 ├── Dockerfile.isaacgym · Dockerfile.newton # 시뮬레이터별 컨테이너 빌드 └── requirements_{isaacgym,isaaclab,newton,mujoco,genesis}.txt # 백엔드별 분리된 의존성
한눈에 읽는 법

envs/base_env/env.py(1,619줄)가 "모든 조각을 지휘하는 오케스트라 지휘자"라면, simulator/base_simulator/simulator.py(1,679줄)는 "어떤 연주자(물리 엔진)를 세워도 같은 악보를 읽게 만드는 규칙집"이다. envs/control·obs·rewards 세 폴더는 각각 "무대 위 배우가 뭘 하는지(control) · 관객이 뭘 보는지(obs) · 배우가 잘했을 때 박수를 얼마나 치는지(reward)"에 해당하며, 이 셋을 절대 한 파일에 섞지 않는 게 이 저장소의 핵심 규율이다. 처음 읽는다면 examples/experiments/steering/mlp.py(가장 간단한 실험 설정) → envs/control/steering_control.pyenvs/obs/steering.pyenvs/rewards/task.py 순서로 "하나의 과제가 어떻게 4개 파일에 걸쳐 조립되는지" 따라가 보는 게 가장 빠르다.

6학습 포인트 (기술별)

이 저장소에서 실제로 무엇을 배울 수 있는가 + 각 주제 실습 아이디어.

학습 1 · 강화학습 — PPO와 AMP의 차이

"목표를 달성하는 것"과 "자연스럽게 움직이는 것"을 동시에 최적화하기

agents/ppo/agent.py(863줄)와 agents/amp/agent.py(34줄, AMP가 사실 PPO를 상속해 판별기 보상만 추가하는 매우 얇은 확장)를 나란히 읽으면, "순수 과제 보상만으로 학습하면 로봇이 어색하게 움직이는 문제"를 AMP가 어떻게 해결하는지 코드 레벨에서 확인할 수 있다. 판별기(discriminator)가 "이 동작이 진짜 사람 동작 데이터와 비슷한지"를 점수 매겨 추가 보상으로 준다.

실습: examples/experiments/steering/mlp.pyagent_config()에서 task_reward_w(과제 보상 vs 스타일 보상 비율) 값을 0.9와 0.1로 각각 바꿔 두 설정 파일을 만들어 보고, "왜 이 값이 학습된 동작의 자연스러움에 영향을 주는지" 코드 주석과 논문을 근거로 설명해 보기.

학습 2 · 물리 시뮬레이션 — 멀티 시뮬레이터 추상화 패턴

"내 코드가 어떤 물리 엔진 위에서 도는지 몰라도 되게 만들기"

simulator/base_simulator/simulator.py의 추상 메서드 목록과, 그중 하나(예: _physics_step)가 isaacgym/simulator.py·newton/simulator.py에서 각각 어떻게 다르게 구현됐는지 나란히 비교해 보자. "인터페이스와 구현을 분리한다"는 객체지향 원칙이 실전 대규모 코드베이스에서 어떻게 쓰이는지 배우는 좋은 사례다.

실습: 직접 만든 미니 물리 시뮬레이션(예: 단순 진자 운동)에 대해 PendulumSimulator 추상 클래스를 정의하고, "느린 파이썬 버전"과 "numpy 벡터화 버전" 두 구현체를 같은 인터페이스로 만들어 속도 차이를 비교.

학습 3 · 휴머노이드 제어 — PD 제어와 관절 게인 설계

"관절이 목표 각도로 부드럽게 움직이게 만드는 물리학"

robot_configs/g1.py를 열어 보면 STIFFNESS_5020·DAMPING_5020 같은 상수가 ARMATURE(관절 관성)·NATURAL_FREQ(고유 진동수, 10Hz)·DAMPING_RATIO(감쇠비, 2.0)로부터 공식으로 유도되는 걸 볼 수 있다 — 이는 BeyondMimic 프로젝트에서 가져온 실전 검증된 PD 게인 설계법이다. "강성(stiffness)이 너무 높으면 로봇이 뻣뻣해지고, 너무 낮으면 목표를 못 따라간다"는 제어이론의 기초를 실제 로봇 설정값으로 체감할 수 있다.

실습: NATURAL_FREQ를 5Hz·10Hz·20Hz로 바꿔가며 각각의 STIFFNESS·DAMPING 값을 손으로 계산해 보고, 이 값이 실제로 관절 반응 속도에 어떤 영향을 줄지 제어이론 관점에서 설명.

학습 4 · 모션 리타겟팅 — 사람 동작을 로봇 관절각으로

"사람과 로봇의 몸이 다른데 어떻게 같은 동작을 시키나"

pyroki/batch_retarget_to_g1_from_keypoints.py(1,257줄)는 사람 골격의 3D 키포인트(관절 위치)를 입력받아, 로봇의 관절각(joint angle)이 그 키포인트에 최대한 가깝게 맞도록 최적화 문제를 푼다. 사람은 팔이 길고 로봇은 짧을 수 있으므로, 이건 "완벽한 복사"가 아니라 "최선의 근사"를 찾는 작업이다.

실습: docs의 리타겟팅 튜토리얼을 참고해, AMASS 샘플 동작 하나를 G1과 H1_2 두 로봇에 각각 리타겟팅해 보고 두 결과의 차이(로봇 팔 길이·관절 범위 차이가 최적화 결과에 미치는 영향)를 비교.

학습 5 · 컴포넌트 기반 아키텍처 — MdpComponent 패턴

"함수 + 데이터 출처 선언을 하나로 묶어 자동 배포 가능하게 만들기"

envs/mdp_component.pyMdpComponentenvs/context_views.pyFieldPath 이중 접근 디스크립터는, "설정 파일에서는 타입 안전한 자동완성을 받고, 런타임에서는 실제 값이 흐르고, 배포 시점에는 자동으로 ONNX 입력 이름을 추출"하는 3중 목적을 하나의 작은 클래스로 달성한다. 파이썬 디스크립터 프로토콜(__get__)을 실전에서 어떻게 쓰는지 배우는 좋은 예제다.

실습: MdpComponent를 참고하지 않고, "함수 + 파라미터 매핑 딕셔너리"를 저장하는 나만의 미니 클래스를 만들어, to_dict()로 사람이 읽을 수 있는 형태로 직렬화하는 기능까지 구현.

학습 6 · Sim2Real — 시뮬레이션에서 학습한 정책을 실제 로봇으로

"학습 때 쓴 관측 계산을 로봇 배포팀이 재구현하지 않게 만드는 법"

deployment/export_bm_tracker_onnx.py는 체크포인트에서 관측 함수 목록을 자동 감지하고, observation 계산 로직까지 ONNX 그래프에 통째로 구워 unified_pipeline.onnx 하나만 넘겨주면 되게 만든다. deployment/test_tracker_mujoco.py(864줄)로 실제 로봇에 넣기 전에 MuJoCo에서 sim2sim 검증까지 거치는 실무 파이프라인 전체를 볼 수 있다.

실습: ONNX 모델 구조를 onnx.helper나 Netron 같은 도구로 열어, 입력 노드 이름들이 실제로 get_bindings_dict()가 만드는 "current.dof_pos" 같은 경로 문자열과 일치하는지 직접 확인.

학습 7 · 생성형 정책 — MaskedMimic과 이산 잠재 공간

"하나의 정책이 여러 개의 '움직이는 법'을 스스로 선택하게 만들기"

agents/common/discrete_latent.py·fsq.py(Finite Scalar Quantization)는 "정책이 매 순간 어떤 스킬(잠재 코드)을 쓸지 스스로 고르는" 생성형 모델의 핵심 부품이다. agents/supervised/masked_mimic_model.py가 이를 지도학습(Supervised)으로 프리트레이닝하는 과정을 보여준다. GPC(Generalist Policy with Composable skills)와 PEFT(어댑터 기반 파인튜닝) 조합을 통해 "재사용 가능한 이산 잠재 프라이어"라는 최근 생성 모델 연구 트렌드를 실전 코드로 접할 수 있다.

실습: examples/experiments/gpc/ 아래 4개 실험 파일(prior.py·sft_target_prior_peft.py 등)을 읽는 순서를 스스로 정해 보고, "프라이어를 먼저 학습한 뒤 PEFT 어댑터를 붙인다"는 2단계 학습 전략을 도식으로 그려 설명.

7하드웨어 / 시스템 요구사항

GPU/CUDA 요구사항 · 시뮬레이터별 규모 · 현실적인 개인 대안.

항목공식 언급 값
GPU (대표 데모)NVIDIA A100 4장 — AMASS 전체(40+시간) 학습에 약 12시간
GPU (대규모 확장)NVIDIA A100 24장 — BONES 데이터셋 13,000개 모션/GPU 규모
Python (IsaacGym)3.8setup.pypython_requires=">=3.8" 및 Dockerfile.isaacgym 기준
Python (Newton)3.10 — Dockerfile.newton 기준, uv 가상환경 사용
CUDA (IsaacGym)12.1.0 (nvidia/cuda:12.1.0-devel-ubuntu20.04 베이스 이미지)
CUDA (Newton)12.4.0 (nvidia/cuda:12.4.0-devel-ubuntu22.04 베이스 이미지)
torch>=2.2(공통) ~ 2.5.0(Genesis 전용 고정)
MuJoCo 전용 제약CPU 전용, num_envs=1 — GPU 없이 빠른 디버깅/재현 용도
디스플레이헤드리스 렌더링용 Xvfb 가상 디스플레이(Dockerfile.newton에 내장)
라이선스Apache-2.0 — 상업적 사용 가능(단, 번들 자산은 legal/의 서드파티 고지 확인 필요)
현실 체크 — 다중 GPU가 사실상 전제된 연구용 프로토타입
A100급 4~24장은 개인이 상시 보유하기 매우 어려운 규모

README 대표 데모(AMASS 전체 학습, A100 4장·12시간)조차 가정용 GPU 1~2장으로는 같은 시간 안에 재현하기 어렵다. IsaacGym·IsaacLab·Newton·Genesis 4종 모두 GPU 필수이며, 대량 병렬 환경(num_envs 수천~수만)을 굴려야 학습 속도의 이점을 체감할 수 있다. "많은 병렬 환경 = 빠른 데이터 수집"이라는 강화학습의 근본 트레이드오프가 이 프로젝트에서는 그대로 GPU 메모리 요구량으로 직결된다.

개인 학습을 위한 현실적 대안
MuJoCo CPU 백엔드 + 소규모 num_envs + 사전학습 체크포인트

① MuJoCo(CPU 전용) 활용requirements_mujoco.txt 안내대로 CPU 전용 torch를 설치하면 GPU 없이도 inference_agent.py --simulator mujoco --num-envs 1로 이미 학습된 체크포인트를 재생·시각화할 수 있다(학습은 불가, 추론/디버깅만). ② 소규모 num_envs로 학습 흉내 — GPU 1장(예: RTX 4090)에서도 num_envs를 수백 개로 낮추면 학습 자체는 돌아간다. 속도는 느리지만 "코드가 실제로 어떻게 도는지" 확인하는 목적은 달성된다. ③ 사전학습 모델 활용 — 저장소의 data/pretrained_models·문서의 사전학습 체크포인트를 내려받아, 학습 없이 추론 파이프라인(inference_agent.py→ONNX export→MuJoCo sim2sim)만 먼저 실습.

용어
num_envs (병렬 환경 개수)
강화학습은 "시도 → 실패 → 조금 개선"을 무수히 반복해야 하는데, 시뮬레이터 하나로 한 번에 하나씩만 시도하면 너무 느리다. GPU 물리 엔진은 수천~수만 개의 독립된 가상 환경을 동시에 돌려, 매 스텝마다 그만큼의 경험을 한 번에 수집한다. num_envs=4096이면 "동시에 4096개의 가상 로봇이 각자 다른 상황에서 연습 중"이라는 뜻이다. 이 숫자가 클수록 학습은 빨라지지만 GPU 메모리를 그만큼 더 요구한다.

8직접 해볼 수 있는 실습 과제

난이도별 5단계 — GPU 없이 코드를 읽는 것부터, GPU 보유자를 위한 전체 학습 파이프라인까지.

과제 1 · 아키텍처 다이어그램 손으로 그려보기 난이도 ★☆☆☆☆

GPU도, 설치도 필요 없는 첫 실습이다. examples/experiments/steering/mlp.py 파일 하나만 읽고, "이 실험이 실행될 때 어떤 순서로 어떤 파일이 호출되는지"를 손으로 화살표 도식을 그려 본다. terrain_config()·env_config()·agent_config() 세 함수가 무엇을 반환하고 train_agent.py의 어느 부분이 그것을 소비하는지 추적하는 것이 목표다.

# 코드를 실행하지 않고 읽기만 해도 되는 실습 — 저장소 클론만
git clone https://github.com/NVlabs/ProtoMotions.git
cd ProtoMotions
cat examples/experiments/steering/mlp.py
# env_config() 함수가 반환하는 EnvConfig의 필드들을 나열해 보기
grep -n "def \|_control\|_obs\|_reward" examples/experiments/steering/mlp.py

과제 2 · MdpComponent 미니 버전 직접 구현 난이도 ★★☆☆☆

protomotions/envs/mdp_component.py를 참고하되 그대로 베끼지 않고, "함수 + 파라미터 매핑"을 저장하는 나만의 MiniComponent 클래스를 파이썬으로 새로 작성한다. compute() 메서드가 딕셔너리에서 실제 값을 찾아와 함수에 넣어 호출하도록 구현하고, 원본의 to_dict() 직렬화 메서드까지 흉내 내 본다.

// 직접 구현해 볼 시그니처 (GPU/torch 불필요, 순수 파이썬으로 연습 가능)
class MiniComponent:
    def __init__(self, compute_func, dynamic_vars: dict, static_params: dict = None):
        self.compute_func = compute_func
        self.dynamic_vars = dynamic_vars     # {param_name: context_key}
        self.static_params = static_params or {}

    def compute(self, ctx: dict):
        # TODO: dynamic_vars의 각 경로를 ctx에서 찾아 실제 값으로 치환한 뒤
        # compute_func(**resolved, **static_params) 호출
        ...

# 테스트 예시
def add(a, b, scale=1.0):
    return (a + b) * scale

comp = MiniComponent(add, {"a": "x", "b": "y"}, {"scale": 2.0})
assert comp.compute({"x": 3, "y": 4}) == 14

과제 3 · MuJoCo CPU 백엔드로 사전학습 체크포인트 재생 난이도 ★★★☆☆

GPU가 없어도 시도할 수 있는 첫 "진짜 실행" 실습이다. requirements_mujoco.txt 안내를 그대로 따라 CPU 전용 conda 환경을 만들고, 공식 문서(Quick Start)가 제공하는 사전학습 체크포인트를 내려받아 재생해 본다. 물리 시뮬레이션이 실제로 로봇의 관절을 움직이는 것을 화면으로 확인하는 것이 이 실습의 핵심이다.

# MuJoCo CPU 백엔드 설치 (requirements_mujoco.txt 안내 그대로)
conda create -n protomotions_mujoco python=3.10
conda activate protomotions_mujoco
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu
pip install -e .
pip install -r requirements_mujoco.txt

# 사전학습 체크포인트로 추론 (num_envs=1 필수)
python protomotions/inference_agent.py \
    --checkpoint results/pretrained/last.ckpt \
    --simulator mujoco \
    --num-envs 1

과제 4 · steering 과제의 보상 가중치 바꿔 학습 결과 비교 난이도 ★★★★☆

GPU 1장(중급 이상)이 있다면, examples/experiments/steering/mlp.pycompute_heading_velocity_rew 호출부에서 방향 일치 가중치(0.7)와 자세 일치 가중치(0.3)를 각각 0.5/0.5, 0.9/0.1로 바꿔가며 세 번 학습시켜 본다. num_envs는 작게(예: 512) 설정해 학습 시간을 단축하고, TensorBoard로 세 실험의 보상 곡선을 겹쳐 비교한다.

# 예시 학습 명령 (GPU 1장, 축소된 num_envs)
python protomotions/train_agent.py \
    --robot-name g1 \
    --simulator isaacgym \
    --experiment-path examples/experiments/steering/mlp.py \
    --experiment-name steering_test_v1 \
    --motion-file data/motions/amass_train.pt \
    --num-envs 512 \
    --batch-size 4096

과제 5 · (GPU 다중 보유자용) 신규 로봇 추가 & sim2sim 파이프라인 완주 난이도 ★★★★★

README의 "Add Your Own Robot" 가이드(MJCF 자산 추가 → robot_configs 설정 채우기 → factory.py에 등록)를 그대로 따라, 간단한 로봇(예: 2족 보행 장난감 수준의 MJCF)을 하나 등록해 본다. 이후 --simulator isaacgym으로 학습한 정책을 --simulator newton·--simulator mujoco로 각각 sim2sim 테스트하며, 3개 물리 엔진에서 행동이 얼마나 일관되는지 직접 관찰하는 것이 최종 목표다.

9관련 기술 심화 학습 로드맵

강화학습 기초 → 물리 시뮬레이션 → 휴머노이드 제어 → sim2real — 8주 계획.

주차주제할 일
1주차강화학습 기초 & PPO정책·보상·가치함수 개념. OpenAI Spinning Up의 PPO 자료 정독 + agents/ppo/agent.py 코드와 대조하며 읽기
2주차물리 시뮬레이터 개념강체 역학·접촉(contact)·PD 제어 기초. simulator/base_simulator/simulator.py의 추상 메서드 20여 개를 표로 정리(과제 1 확장)
3주차모션 모방 학습(AMP/ASE)Adversarial Motion Priors 원 논문 요약 + agents/amp/agent.py·component.py 정독. 판별기가 왜 "자연스러움"을 학습시키는지 이해
4주차MdpComponent 아키텍처파이썬 디스크립터 프로토콜(__get__/__set_name__) 공식 문서 + context_paths.py·context_views.py 재독. 과제 2(미니 구현) 완주
5주차휴머노이드 제어(PD 게인)제어이론의 2차 시스템(고유진동수·감쇠비) 기초 + robot_configs/g1.py의 게인 계산식 재해석
6주차모션 리타겟팅역기구학(IK) 최적화 기초 + PyRoki 공식 문서. pyroki/batch_retarget_to_g1_from_keypoints.py 정독, 과제 3 완주
7주차생성형 정책(MaskedMimic/GPC)이산 잠재변수(VQ-VAE류) 개념 + FSQ(Finite Scalar Quantization) 논문 요약. agents/common/fsq.py 재독
8주차Sim2Real 배포ONNX 그래프 구조, 배포 시 관측 일치의 중요성. deployment/export_bm_tracker_onnx.py+test_tracker_mujoco.py 완독, 과제 5(GPU 있으면) 도전
학습 순서 팁

이 저장소는 강화학습 이론 · 물리 시뮬레이션 시스템 · 로보틱스 제어라는 세 개의 서로 다른 전문 분야가 겹쳐 있다. 한 번에 다 이해하려 하면 좌절하기 쉽다. 먼저 "가장 간단한 과제 하나"(steering)를 처음부터 끝까지 따라가 보고 → 그 다음 시뮬레이터 추상화 계층을 이해하고 → 마지막에 로보틱스 응용(리타겟팅·sim2real)으로 확장하는 순서를 추천한다. 강화학습 기초가 약하다면 1주차를 건너뛰지 말 것 — AMP/GRPO류 알고리즘 코드를 읽어도 "왜 이렇게 계산하는지"가 안 잡히면 암기가 되어버린다.

10핵심 키워드 사전

이 문서와 저장소에 나온 주요 용어 정리.

용어
AMASS (Archive of Motion Capture as Surface Shapes)
여러 모션 캡처 데이터셋을 SMPL 포맷으로 통일해 모아 놓은 대규모 공개 사람 동작 데이터셋(40시간 이상). ProtoMotions가 모방 학습의 기본 교재로 사용한다.
용어
SMPL / SMPL-X (Skinned Multi-Person Linear model)
사람의 몸 형태와 자세를 소수의 파라미터(형태 파라미터 + 관절 각도)로 표현하는 표준화된 3D 인체 모델. 컴퓨터 그래픽스·비전 연구에서 널리 쓰이는 "사람 모델의 공통 언어"다. SMPL-X는 손가락·얼굴 표정까지 포함한 확장판.
용어
리타겟팅(Retargeting)
한 골격(사람)에서 캡처한 동작을 다른 골격(로봇)에 옮기는 과정. 팔 길이·관절 범위가 다른 몸에 "최선의 근사"로 동작을 이식하는 최적화 문제다. 이 저장소는 PyRoki를 사용한다(구버전은 Mink).
용어
PyRoki
로봇 역기구학(IK)·리타겟팅 최적화를 위한 오픈소스 라이브러리(chungmin99/pyroki). ProtoMotions3부터 채택되어 AMASS 전체를 한 명령으로 로봇 관절각으로 변환하는 데 쓰인다.
용어
PPO (Proximal Policy Optimization, 근접 정책 최적화)
정책을 한 번에 너무 크게 바꾸지 않도록 업데이트 폭을 제한하는 강화학습 알고리즘. ProtoMotions의 agents/ppo/가 이 알고리즘의 기본 구현체이며, 다른 에이전트(AMP·ASE 등)들이 이를 상속해 확장한다.
용어
AMP (Adversarial Motion Priors, 적대적 동작 사전지식)
판별기(discriminator) 신경망이 "이 동작이 실제 사람 동작 데이터와 비슷한지"를 점수 매겨 추가 보상으로 주는 기법. 순수 과제 보상만으로는 부자연스러운 동작이 나오는 문제를 완화한다.
용어
ASE (Adversarial Skill Embeddings)
AMP를 확장해, 정책이 잠재 공간(latent space)에서 다양한 스킬을 학습하도록 만드는 기법. 하나의 정책이 여러 개의 서로 다른 동작 스타일을 잠재 코드로 구분해 표현할 수 있게 한다.
용어
ADD (에이전트, agents/mimic/agent_add.py)
이 저장소에서 AMP를 상속해 약 100줄의 추가 코드만으로 구현된 모션 추적(mimic) 알고리즘. "새 RL 알고리즘을 적은 코드로 실험할 수 있다"는 이 저장소의 모듈성 주장을 뒷받침하는 예시로 README가 직접 인용한다.
용어
MaskedMimic
NVIDIA Research가 개발한 생성형 정책 기법으로, 하나의 정책이 다양한 조건(부분 관측·목표 자세 등)에 맞춰 스스로 적절한 동작을 선택하도록 학습시킨다. agents/supervised/masked_mimic_model.py가 이를 구현한다.
용어
GPC (Generalist Policy with Composable skills) & PEFT (Parameter-Efficient Fine-Tuning)
GPC는 "재사용 가능한 스킬 프라이어를 먼저 학습한 뒤, 신규 과제마다 가벼운 어댑터만 추가 학습"하는 전략이다. PEFT는 모델 전체가 아니라 일부 파라미터(어댑터)만 학습시켜 효율을 높이는 기법으로, 언어모델의 LoRA와 유사한 개념이 로보틱스 정책에 적용된 사례다.
용어
FSQ (Finite Scalar Quantization)
신경망의 연속적인 잠재 벡터를 유한한 개수의 이산 코드로 양자화(quantization)하는 기법. VQ-VAE류 이산 잠재변수 학습을 더 단순하고 안정적으로 만든 최신 방법 중 하나로, MaskedMimic/GPC의 스킬 표현에 사용된다.
용어
PD 제어 (Proportional-Derivative Control, 비례-미분 제어)
"목표 위치와 현재 위치의 차이(비례항)"와 "속도 오차(미분항)"를 함께 반영해 힘을 계산하는 가장 기본적인 로봇 관절 제어 방식. robot_configs/g1.py의 강성(stiffness)·감쇠(damping) 값이 이 제어기의 핵심 파라미터다.
용어
Sim2Real / Sim2Sim
Sim2Real은 "시뮬레이션에서 학습한 정책을 실제 로봇에 배포"하는 과정, Sim2Sim은 그 전 단계로 "한 시뮬레이터에서 학습한 정책을 다른 시뮬레이터에서 검증"하는 과정이다. 두 시뮬레이터에서 결과가 비슷하면 실제 로봇에서도 잘 작동할 가능성이 높다고 판단한다.
용어
ONNX (Open Neural Network Exchange)
여러 딥러닝 프레임워크(PyTorch·TensorFlow 등) 사이에서 학습된 모델을 교환하기 위한 표준 포맷. 로봇 배포 환경은 보통 PyTorch 전체를 설치하지 않으므로, 정적 그래프로 굳힌 ONNX 모델 하나만 넘겨 가볍게 실행한다.
용어
MdpComponent
관측/보상/종료 계산 함수(compute_func)를 데이터 출처(dynamic_vars의 FieldPath)와 고정 상수(static_params)로 분리해 담는 이 저장소 고유의 설계 패턴. 설정 코드의 타입 안전성과 ONNX 배포 자동화를 동시에 달성한다.
용어
FieldPath
EnvContext 클래스에 선언된, "이 값이 컨텍스트의 어느 경로에 있는지"를 나타내는 디스크립터 객체. 클래스로 접근하면 경로 정보를, 인스턴스로 접근하면 실제 텐서 값을 반환하는 이중 역할을 한다.
용어
Newton (물리 엔진)
NVIDIA·Google DeepMind 등이 공동 개발 중인 차세대 오픈소스 GPU 물리 시뮬레이터로, warp-lang(NVIDIA의 GPU 커널 작성용 파이썬 프레임워크) 위에 구축된다. IsaacGym·IsaacLab을 잇는 미래 방향으로 여겨진다.
용어
USD (Universal Scene Description)
픽사가 만들고 NVIDIA Omniverse가 채택한 3D 장면 교환 표준 포맷. 여러 3D 소프트웨어 사이에서 씬·재질·물리 속성을 손실 없이 주고받는 데 쓰인다.
용어
MJCF (MuJoCo XML)
MuJoCo 물리 엔진이 로봇/오브젝트의 형태와 관절 구조를 정의하는 XML 기반 파일 포맷. 이 저장소에 신규 로봇을 추가하는 첫 단계가 바로 이 .xml 파일을 작성하는 것이다.
용어
Kimodo
NVIDIA의 텍스트-투-모션(text-to-motion) 생성 모델. 텍스트 프롬프트로부터 동작을 생성하면, ProtoMotions가 그 동작을 물리 기반 정책으로 다시 학습시켜 실제 로봇에서도 재현 가능하게 만든다.

11참고 링크

공식 저장소 · 공식 문서 · 관련 프로젝트 · 데이터셋.

구분링크
GitHub 저장소github.com/NVlabs/ProtoMotions
공식 문서protomotions.github.io
Quick Startprotomotions.github.io/getting_started/quickstart.html
설치 가이드protomotions.github.io/getting_started/installation.html
G1 실기 배포 튜토리얼protomotions.github.io/tutorials/workflows/g1_deployment.html
GPC & PEFT 가이드protomotions.github.io/user_guide/gpc.html
API 레퍼런스protomotions.github.io/api_reference
자매 프로젝트 MimicKitgithub.com/xbpeng/MimicKit — 경량 모션 모방 학습 프레임워크
PyRoki (리타겟팅)github.com/chungmin99/pyroki
Newton 물리 엔진github.com/newton-physics/newton
AMASS 데이터셋amass.is.tue.mpg.de
BONES-SEED 데이터셋huggingface.co/datasets/bones-studio/seed
Kimodo (텍스트-투-모션)research.nvidia.com/labs/sil/projects/kimodo
MaskedMimic 연구 페이지research.nvidia.com/labs/par/maskedmimic
RoboJuDo (실기 배포 프레임워크)github.com/HansZ8/RoboJuDo
IsaacLab (비교 대상)github.com/isaac-sim/IsaacLab
DeepWiki 비공식 문서(AI 생성)deepwiki.com/NVlabs/ProtoMotions
라이선스Apache-2.0 (상업적 이용 가능, 서드파티 자산 고지는 legal/ 참고)