📃TACTO 리뷰

tactile

simulation

A Fast, Flexible, and Open-source Simulator for High-Resolution Vision-based Tactile Sensors

Published

March 25, 2026

Paper Link
Code Link
Shaoxiong Wang, Mike Lambeta, Po-Wei Chou, Roberto Calandra
IEEE Robotics and Automation Letters (RA-L), 2022

💡 TACTO는 기존 시뮬레이터들이 구현하기 어려웠던 고해상도 vision-based tactile sensors의 사실적인 촉각 신호를 초당 수백 프레임으로 렌더링할 수 있는 빠르고 유연한 오픈소스 시뮬레이터입니다.
⚙️ 이 시뮬레이터는 PyBullet 같은 물리 엔진과 Pyrender 같은 렌더링 엔진을 연결하며, 물체 메쉬를 미리 로드하고 포즈를 동기화하는 OpenGL 기반 아키텍처를 통해 높은 유연성과 고속 렌더링을 제공합니다.
🎯 저자들은 TACTO를 사용하여 100만 건의 그랩 데이터로 그랩 안정성을 학습하고, 대리석 조작 제어를 시뮬레이션하며, Sim2Real 격차를 줄이는 등 다양한 로봇 및 AI 애플리케이션에서의 잠재력을 입증했습니다.

🔍 Ping Review

🔍 Ping — A light tap on the surface. Get the gist in seconds.

TACTO는 고해상도 시각 기반 촉각 센서를 위한 빠르고 유연하며 오픈 소스 시뮬레이터입니다. 이 시뮬레이터는 로봇 공학 및 제어 학습 분야에서 새로운 발전을 프로토타이핑, 디버깅 및 벤치마킹하는 데 중요한 역할을 합니다. 기존의 물리 엔진들은 시각 기반 촉각 센서와 같은 고해상도 촉각 센서의 정확한 시뮬레이션에 어려움을 겪었는데, 이는 접촉 역학뿐만 아니라 센서의 광학적 특성 및 해당 조명을 모델링해야 하기 때문입니다. TACTO는 이러한 격차를 해소하여 초당 수백 프레임으로 사실적인 고해상도 터치 데이터를 렌더링할 수 있으며, DIGIT 및 OmniTact를 포함한 다양한 시각 기반 촉각 센서를 시뮬레이션하도록 쉽게 구성할 수 있습니다.

이 논문은 TACTO의 구현을 이끈 원칙들과 그 원칙들이 아키텍처에 어떻게 반영되었는지 상세히 설명합니다. TACTO는 높은 처리량, 유연성, 현실성, 그리고 사용 편의성을 목표로 설계되었습니다.

핵심 방법론:

TACTO는 접촉 영역의 국부 기하학(Depth) 및 해당 렌더링(RGB)을 계산하기 위해 PyBullet과 같은 물리 시뮬레이터와 Pyrender(OpenGL 기반)와 같은 백엔드 렌더링 엔진을 연결합니다. 기존 접근 방식의 한계점을 극복하기 위해 “동기화된 장면에서 OpenGL을 사용한 RGB 렌더링” 방식을 제안합니다.

퐁 모델을 사용한 RGB 렌더링 (간단하지만 덜 강력): PyBullet의 내장 카메라가 제공하는 깊이 맵에서 RGB 이미지를 렌더링하는 방식입니다. 퐁의 반사 모델을 기반으로 하지만, 빛이 젤 표면에서 카메라로 한 번만 반사된다고 가정하므로, 반사, 굴절, 그림자와 같은 고급 기능에 적합하지 않으며 GPU 가속화가 어렵습니다.
깊이에서 OpenGL을 사용한 RGB 렌더링 (강력하지만 느림): OpenGL의 강력한 기능을 활용하여 깊이 맵으로부터 RGB 이미지를 렌더링하는 방식입니다. 미러, 투명 객체, 그림자, GPU 가속 등을 지원하지만, 깊이 맵에서 생성된 메시를 OpenGL로 반복적으로 로드하는 I/O 병목 현상으로 인해 속도가 초당 20프레임으로 제한됩니다.
동기화된 장면에서 OpenGL을 사용한 RGB 렌더링 (제안된 방식 - 강력하고 빠름): TACTO의 핵심 아키텍처입니다. I/O 병목 현상을 피하기 위해, TACTO는 젤 표면과 객체 메시를 OpenGL 장면에 미리 로드합니다. 그런 다음 물리 시뮬레이터(예: PyBullet)에서 객체와 센서의 포즈(x, y, z, \text{roll}, \text{pitch}, \text{yaw} 또는 사원수 x, y, z, q_x, q_y, q_z, q_w)를 가져와 렌더링 엔진에서 해당 포즈를 동기화하고, 재렌더링합니다. 메시를 로드하는 것은 느리지만, 포즈를 변경하는 것은 매우 빠르므로, 이 방식을 통해 초당 최대 200프레임의 높은 속도를 달성합니다.
- 초기화 (Initialize): TACTO는 센서 구성(카메라, 조명, 젤 메시)을 로드하고 렌더링 엔진에 설정합니다.
- 장면 생성 (Create Scene): PyBullet이 객체 URDF를 장면에 로드하면, TACTO는 URDF를 파싱하여 분석된 메시를 렌더링 엔진에 추가합니다.
- 시뮬레이션 스텝 (Step Simulation): PyBullet이 물리 시뮬레이션(접촉 힘, 객체 포즈 등)을 계산한 후, TACTO는 PyBullet에서 각 링크의 포즈를 가져와 렌더링 엔진의 객체 및 센서 포즈를 동기화하고, 렌더링된 촉각 이미지를 가져옵니다.

주요 특징:

빠른 속도: 12K 면을 가진 객체 메시와 상호작용 시, 160x120 해상도에서 GPU로 단일 DIGIT 센서를 초당 200프레임으로 렌더링 가능합니다. 접촉하는 객체의 수에 따라 렌더링 속도가 영향을 받도록 최적화되어 있습니다.
유연성: 구성 파일 변경만으로 DIGIT 및 OmniTact와 같은 다양한 센서 디자인을 지원합니다.
힘 의존적 변형: 물리 엔진에서 측정된 접촉 힘을 젤 메시의 변형 깊이에 매핑하는 함수를 적용하여 젤의 동적 범위 변형을 시뮬레이션합니다. 현재는 선형 탄성을 근사하는 조각별 선형 매핑을 사용합니다.
깊이로부터 렌더링: 깊이 이미지를 기반으로 촉각 이미지를 렌더링하는 옵션도 제공하여, 더 현실적인 촉각 이미지를 위해 깊이 이미지를 수정해야 하는 경우에 유용합니다.
실제 센서로부터의 보정: 실제 센서에서 수집된 데이터를 사용하여 시뮬레이터 렌더링을 미세 조정할 수 있는 절차를 지원하여, 실제 측정과 유사한 조명 분포 및 그림자를 구현할 수 있습니다.
다양한 물리 엔진과의 호환성: PyBullet을 기본으로 사용하지만, 객체/링크 포즈 및 접촉 힘을 동기화하거나 깊이 정보만으로 렌더링하는 방식을 통해 다른 물리 엔진과도 연동 가능합니다.

시뮬레이션 실험:

파악 안정성 학습: TACTO를 사용하여 100만 개의 파악 데이터를 수집하고, 시각 및 촉각 신호로부터 파악 안정성을 예측하는 분류기를 학습했습니다. 결과는 촉각이 시각보다 적은 데이터로도 빠르게 학습되며, 두 개의 촉각 센서가 단일 센서보다 우수함을 보여주었습니다. 시뮬레이션 덕분에 실제 환경에서는 불가능했던 대규모 데이터셋(이전 최대 데이터셋보다 두 자릿수 이상 많음)으로 실험이 가능했습니다.
인핸드 구슬 조작 학습: TACTO와 PyBullet의 안정성을 검증하기 위해 촉각 센서를 사용하여 구슬을 손 안에서 조작하는 작업을 시뮬레이션했습니다. 베이시안 최적화를 사용하여 구슬을 원하는 위치로 굴리는 컨트롤러의 파라미터 K를 학습했습니다. 이 실험은 시뮬레이션이 빠르고 안정적으로 작동하며, 실제 로봇에서 얻은 결과와 유사한 성능을 달성할 수 있음을 입증했습니다.

Sim2Real 실험:

원통의 포즈 추정(접촉 중심 및 각도) 작업에 대한 Sim2Real 가능성을 입증했습니다. 시뮬레이션 데이터와 실제 데이터를 조합하여 모델을 훈련하고 평가했습니다.
결과: Sim2Real 간극이 존재하며, 컬러 지터링과 같은 데이터 증강(data augmentation)이 이 간극을 줄이는 데 매우 효과적임을 보여주었습니다. 또한, 시뮬레이션 데이터와 소량의 실제 데이터를 혼합하여 학습할 때, 동일한 양의 실제 데이터만으로 학습한 경우보다 높은 성능을 달성하여 데이터 효율성 증가의 잠재력을 시사했습니다.

결론:

TACTO는 시각 기반 촉각 센서를 위한 사용하기 쉽고 빠르며 유연한 시뮬레이터입니다. 이 시뮬레이터는 지각, 제어 및 Sim2Real 응용 분야에서 그 유용성이 입증되었습니다. TACTO는 촉각 센싱 커뮤니티를 육성하고 로봇 공학 및 기계 학습 연구자들이 시뮬레이션에서 터치를 활용할 수 있도록 오픈 소스로 제공됩니다. 향후 작업에는 엘라스토머의 변형을 통한 힘의 효과 모델링 개선과 더욱 현실적인 데이터 생성이 포함될 것입니다.

🔔 Ring Review

🔔 Ring — An idea that echoes. Grasp the core and its value.

한 줄로 시작하면

촉각 센서를 시뮬레이션하는 데에서 가장 어려운 부분은 물리가 아니라 광학이다. TACTO는 이 관찰을 정확히 짚고, 물리 엔진은 PyBullet에 맡기고 자신은 “잘 동기화된 장면을 OpenGL로 빠르게 렌더링하는 일”에 집중한다. 그 결과 GPU에서 초당 수백 프레임으로 DIGIT, OmniTact 같은 vision-based tactile sensor의 출력을 만들어내는, 단순하지만 영리한 도구가 나왔다.

이 글에서는 TACTO가 왜 이런 설계를 택했는지, 어떤 트레이드오프를 받아들였는지, 그리고 Allegro Hand 같은 다손가락 플랫폼이나 sim-to-real 연구자에게 실제로 어떤 의미가 있는지를 한 호흡으로 정리한다.

왜 촉각 시뮬레이션이 그렇게 어려운가

먼저 vision-based tactile sensor가 어떻게 동작하는지 떠올려보자. DIGIT나 GelSight 계열 센서는 작은 카메라가 부드러운 실리콘 젤의 아래쪽을 들여다보는 구조다. 젤 옆면에는 작은 LED 몇 개가 박혀 있고, 빛은 젤 안에서 굴절·반사된다. 어떤 물체가 젤을 누르면 젤 표면이 변형되고, 그 변형이 카메라에 일종의 “지문 이미지”로 찍힌다.

이걸 시뮬레이션하려면 세 가지를 동시에 해야 한다.

접촉 동역학 (얼마나 깊이 눌리고, 얼마나 미끄러지는지 (마찰))
젤의 변형 (탄성 재료가 물체 형상에 맞춰 어떻게 변형되는지)
광학 (LED 빛이 젤 내부를 통과해서 어떤 색·밝기·그림자 패턴을 만드는지)

기존 촉각 시뮬레이터들이 잘 안 풀린 이유는 이 셋을 한꺼번에 정확히 하려고 했기 때문이다. 그런데 잘 생각해보면, 머신러닝 정책 학습 입장에서는 광학적 출력 (RGB 이미지)이 가장 중요하다. 정책은 결국 이미지를 보고 행동을 결정하기 때문이다. 접촉 동역학은 물리 엔진이 적당히 처리해주면 되고, 젤 변형은 “센서가 본 깊이 맵”으로 환원할 수 있다.

TACTO는 이 트레이드오프를 정직하게 받아들이는 데에서 출발한다. 접촉 동역학의 정확도는 PyBullet의 강체 모델에 위임하고, 자신은 “그럴듯한 이미지를 빠르게 만드는” 데 모든 자원을 쏟는다.

설계 철학: 빠르고, 유연하고, 현실적이고, 다루기 쉽게

논문이 직접 명시한 네 가지 desiderata는 그대로 가져갈 가치가 있다.

High-throughput (속도): 강화학습이나 베이지안 최적화처럼 수십만~수백만 스텝이 필요한 학습에 쓰려면 수백 Hz는 나와야 한다.
Flexible (유연성): DIGIT은 평평한 젤 하나에 카메라 하나지만, OmniTact는 둥근 표면에 카메라 5개와 광원 11개가 박혀 있다. 미래에 나올 거울/투명 케이스/light-piping 설계도 받아낼 수 있어야 한다.
Realistic (현실성): 단순히 깊이 맵 비슷한 게 아니라, 비균일 조명, 그림자, 접촉 경계의 디테일까지 살아야 한다.
Easy to Use (사용성): 설치하고 띄우는 데 며칠씩 걸리면 아무도 안 쓴다.

이 네 가지를 동시에 만족시키는 방법은 한 줄로 요약하면 “이미 잘 만들어진 컴퓨터 그래픽스 도구를 최대한 빌려 쓰자”다. Phong 모델을 직접 코딩하는 대신, OpenGL과 Pyrender가 이미 GPU에서 최적화해놓은 ray-tracing 기능을 그대로 활용한다.

세 갈래 길에서 어떻게 선택했나

이 부분이 TACTO 논문에서 가장 시스템 설계자다운 대목이다. 저자들은 후보 아키텍처 세 가지를 명시적으로 비교한다.

선택지 A: Phong 모델로 깊이→RGB 렌더링

PyBullet의 내장 카메라로 깊이 맵을 얻고, 그 위에 Phong 반사 모델을 직접 적용해 RGB를 칠하는 방식이다. 구현이 간단하고 결과도 그럴듯하지만, 빛이 한 번만 튕긴다는 가정이라 거울·투명 재질·그림자 같은 고급 효과를 추가하기 어렵다. GPU 가속까지 직접 만들려면 엔지니어링 비용이 빠르게 불어난다.

선택지 B: OpenGL로 깊이→RGB 렌더링

깊이 맵에서 메쉬를 만들고, 그 메쉬를 OpenGL에 넘겨서 풍부한 광학 효과까지 한 번에 처리하는 방식이다. 렌더링 자체는 빠르지만, 매 스텝마다 새 메쉬를 OpenGL에 로드하는 I/O가 병목이 된다. 논문의 사전 실험에서 GPU를 써도 20 FPS에 묶였다고 나온다.

선택지 C: 동기화된 장면을 OpenGL로 렌더링 (채택)

여기서 영리한 발상이 나온다. 메쉬를 매번 새로 만들고 로드하지 말고, 처음에 한 번만 로드하고 그 다음부터는 자세만 갱신하자. 젤 표면 메쉬와 물체 메쉬는 OpenGL 장면에 미리 올려두고, 매 스텝 PyBullet에서 자세 (pose)만 받아와서 업데이트한다.

접촉이 일어나는 순간에는 어떻게 처리할까? 그냥 두 메쉬가 서로 파고들도록 둔다. OpenGL은 depth buffer로 가까운 표면을 자동으로 골라내기 때문에, 카메라 시점에서 보면 물체가 젤을 누른 것처럼 깊이가 만들어지고, 그 위에 빛·재질·그림자가 자연스럽게 얹힌다.

이 트릭의 본질은 “이미 GPU가 잘하는 일은 GPU에게 맡기고, 우리는 자세 동기화만 한다”는 것이다. 비유하자면 인형극에서 인형의 위치는 무대 뒤에서 줄로 당겨 옮기고, 조명과 무대 풍경은 미리 세팅해둔 그대로 두는 것과 같다.

대가는 무엇인가. 두 메쉬가 그냥 겹치므로 접촉 경계에서 젤이 부드럽게 휘는 자연스러운 변형은 안 잡힌다. 날카로운 모서리에서 이게 두드러진다. 논문은 이 한계를 정직하게 인정하면서, 물체 메쉬를 사전에 살짝 스무딩하거나 학습 후에 generative model로 보정하면 된다고 제안한다. 그리고 한 가지 더, “접촉 경계의 미세 디테일보다 접촉 위치·마스크·자세·법선력 같은 정보가 학습에 더 중요하니 이 정도 절충은 받아들일 만하다”고 말한다. 이건 경험적으로 보면 합당한 판단이다.

아키텍처 전체 그림

flowchart LR
    A[User Code] --> B[Physics Engine<br/>PyBullet]
    A --> C[TACTO<br/>Bridge Layer]
    B -->|object/link poses<br/>contact forces| C
    C -->|deformed gel + objects<br/>synchronized scene| D[Pyrender / OpenGL<br/>GPU rendering]
    D -->|RGB + Depth| C
    C -->|tactile imprint| A
    E[Sensor Config<br/>camera, lights,<br/>gel mesh, deformation] --> C

TACTO는 본질적으로 물리 엔진과 렌더링 엔진 사이의 다리 역할이다. 설정 파일 하나만 바꾸면 DIGIT에서 OmniTact로, 또는 새로 설계한 센서로 갈아끼울 수 있다.

런타임은 3단계로 흘러간다.

sequenceDiagram
    participant U as User
    participant T as TACTO
    participant P as PyBullet
    participant R as Pyrender
    Note over T,R: Phase 1 - Initialize
    U->>T: load sensor config
    T->>R: setup camera, lights, gel mesh
    Note over T,R: Phase 2 - Create scene
    U->>P: load object URDF
    T->>P: parse URDF (urdfpy)
    T->>R: add object meshes
    Note over T,R: Phase 3 - Step simulation (loop)
    P->>P: physics step
    T->>P: get link poses, contact forces
    T->>R: sync poses, apply gel deformation
    R->>T: rendered RGB + Depth
    T->>U: tactile imprint

이 단순한 워크플로의 장점은 어떤 물리 엔진과도 결합할 수 있다는 점이다. 자세를 조회하고 접촉력을 가져오는 함수만 있으면 Isaac Lab, MuJoCo, 어디든 붙일 수 있다. 자세 동기화가 까다로운 경우에는 깊이 이미지만 받아서 메쉬를 만드는 (선택지 B) 우회로도 열려 있다.

힘에 따른 젤 변형: 단순하지만 작동하는 모델

TACTO는 젤의 변형을 유한요소법으로 풀지 않는다. 대신 PyBullet이 알려주는 법선력 F_n을 변형 깊이 d에 매핑하는 piece-wise linear 함수를 쓴다. 직관적으로 적으면 이렇다.

d(F_n) = \begin{cases} 0, & F_n < F_{\text{low}} \\ k \cdot (F_n - F_{\text{low}}), & F_{\text{low}} \le F_n \le F_{\text{high}} \\ d_{\text{max}}, & F_n > F_{\text{high}} \end{cases}

F_{\text{low}}: 이보다 작은 힘은 센서가 못 느낀다 (실제 센서의 노이즈 플로어)
F_{\text{high}}: 이보다 큰 힘은 젤이 포화되어 더 이상 깊이가 깊어지지 않는다
그 사이는 선형 (실제 실리콘의 선형 탄성 영역 근사)

왜 이렇게 단순할까. 실제 DIGIT 젤의 측정 데이터를 보면 적당한 힘 범위에서는 선형성이 꽤 잘 맞고, 양 끝을 클리핑해주면 실제 동작 범위를 충분히 흉내 낼 수 있기 때문이다. 사용자가 비선형 함수를 직접 끼워 넣을 수 있도록 설계되어 있다는 점도 중요하다. 더 정교한 hyperelastic 모델을 쓰고 싶다면 그 자리에 함수를 갈아끼우면 된다.

이 단순화는 강체 가정 위에 얹혀 있다. 즉, “물체는 단단하고, 젤만 부드럽다”는 가정이다. 일상 사물 (병뚜껑, 큐브, 공구) 대부분에 대해서는 합당하다. 매우 변형 가능한 물체 (천, 두부, 빵)에는 적합하지 않다.

조명, 그림자, 그리고 캘리브레이션

여기서부터가 TACTO가 단순한 toy 시뮬레이터를 넘는 부분이다.

비균일 조명. 실제 DIGIT 센서를 손에 들고 보면 한쪽 모서리는 밝고 반대편은 어두운, 묘하게 핑크빛이 도는 색감이 나온다. LED에서 멀어질수록 빛이 약해지기 때문이다. TACTO는 OpenGL의 광원 모델을 그대로 써서 이걸 자연스럽게 재현한다 (논문 Fig. 7). 별도로 코딩한 것이 아니라, 광원의 위치·강도·색을 설정 파일에 정확히 적어주기만 하면 OpenGL이 알아서 렌더링한다.

그림자. 작은 구슬 같은 물체가 젤에 살짝 닿을 때, 실제 센서는 접촉점 주변에 부드러운 그림자가 떨어진다. TACTO에서 그림자를 켜는 것은 설정 토글 하나로 끝난다. GPU에서 약 2 ms가 추가될 뿐이다 (논문 Fig. 8). Phong 모델로 이걸 직접 구현하려면 작업량이 엄청나다는 점을 생각하면, OpenGL을 빌려 쓴 게 큰 이득이다.

실제 센서로부터의 캘리브레이션. 시뮬레이션이 아무리 정교해도 실제 센서의 미세한 흠집, 카메라 노이즈, 광원 불균일까지 다 잡을 수는 없다. TACTO는 영리하게 우회한다 (논문 Fig. 6).

시뮬레이션에서 “접촉 없음” 이미지 I_{\text{sim}}^{\text{empty}}를 만든다.
시뮬레이션에서 “접촉 있음” 이미지 I_{\text{sim}}^{\text{contact}}를 만든다.
픽셀별 차분 \Delta I = I_{\text{sim}}^{\text{contact}} - I_{\text{sim}}^{\text{empty}}를 계산한다.
실제 센서에서 미리 찍어둔 빈 이미지 I_{\text{real}}^{\text{empty}} 위에 \Delta I를 더한다.

I_{\text{final}} = I_{\text{real}}^{\text{empty}} + \left( I_{\text{sim}}^{\text{contact}} - I_{\text{sim}}^{\text{empty}} \right)

이렇게 하면 변형 신호는 시뮬레이션에서, 배경 텍스처는 실제 센서에서 가져오는 합성 이미지가 만들어진다. 각 개별 센서마다 빈 이미지 한 장만 찍어두면 적용 가능하다는 점이 큰 장점이다. 추가로 작은 가우시안 필터 (15×15 정도)를 RGB에 씌우면 카메라 렌즈·광원 결함까지 자연스럽게 흉내낸다 (논문 Fig. 9).

속도: 표 한 장으로 보는 실측치

TACTO의 가장 인상적인 부분은 속도다. 논문 Table I의 측정치를 풀어서 적으면 다음과 같다 (GPU: RTX 2080 Super 기준, 12K faces 메쉬).

해상도	1 object (접촉 1개)	100 objects (접촉 1개)	100 objects (접촉 10개)
160×120	220 FPS	200 FPS	80 FPS
320×240	140 FPS	100 FPS	60 FPS
640×480	90 FPS	90 FPS	50 FPS

여기서 두 가지 디테일이 중요하다.

첫째, 장면에 있는 물체 수가 100개로 늘어도 속도가 거의 그대로다. 접촉 중인 물체 수만 렌더링 시간에 영향을 준다. cluttered 환경 (창고 박스 같은 곳)에서도 무리 없이 쓸 수 있다는 뜻이다.

둘째, 메쉬 면 수가 2K에서 12K로 늘어도 GPU에서는 속도 변화가 없다. GPU 병렬화가 잘 먹는다는 신호다.

CPU만 쓰면 40~60 FPS 정도로 떨어지지만, 그래도 실시간보다는 빠르다. Allegro Hand에 DIGIT 4개를 달면 GPU에서 50 FPS 정도가 나온다고 명시되어 있다 (논문 Sec. III-D). 5손가락 humanoid 손에 센서 10~15개를 다는 시나리오라면 해상도를 조금 낮추거나 멀티 GPU를 검토해야 할 수 있다.

실험 1: 100만 grasp으로 잡기 안정성 배우기

논문의 첫 실험은 vision-based tactile sensor 시뮬레이션이 왜 가치가 있는지를 보여주는 가장 좋은 사례다.

설정

WSG-50 평행 그리퍼에 DIGIT 두 개를 달고, 외부 카메라 하나를 추가한다. 그리퍼의 위치·자세·힘을 무작위로 바꿔가며 박스를 잡아 들어 올리고, 들어 올린 뒤에도 박스가 손가락 사이에 남아 있는지로 라벨을 매긴다 (성공/실패 이진 분류).

이 데이터를 하루 동안 5스레드로 100만 개를 모았다. 실제 로봇으로 같은 일을 한 선행 연구에서 모은 데이터셋이 약 6,000 grasp 규모였던 것을 생각하면 두 자릿수 배 더 큰 데이터다.

모델

ResNet-18을 ImageNet 사전학습 가중치로 초기화해서, vision과 touch를 각각 별도 백본에 통과시킨 뒤 feature 벡터를 concat해서 두 층 (512, 256 hidden units)의 FC에 넣는다. 출력은 grasp 성공 확률.

Input:
  vision_img  : 160x120 RGB
  touch_left  : 160x120 RGB
  touch_right : 160x120 RGB

Encoder:
  f_v = ResNet18(vision_img)
  f_l = ResNet18(touch_left)
  f_r = ResNet18(touch_right)

Fusion:
  z = concat([f_v, f_l, f_r])
  h1 = ReLU(Linear(z, 512))
  h2 = ReLU(Linear(h1, 256))
  y_hat = Sigmoid(Linear(h2, 1))

Loss:
  L = BCE(y_hat, grasp_success_label)

학습은 Adam, lr=5 \times 10^{-4}, batch=32, 10 epochs.

결과의 의미

논문 Fig. 10 오른쪽의 학습 곡선이 모든 것을 말해준다.

촉각만 써도 적은 데이터로 빠르게 정확도가 올라간다. 비전만 쓰면 같은 정확도에 도달하려면 3~4 자릿수 배 더 많은 데이터가 필요하다. 직관적으로 보면 박스의 미끄러짐 여부는 손가락 끝의 접촉 패턴에 직결되지만, 외부 카메라가 보는 그림은 박스의 전체 모양에서 그 신호를 짜내야 하기 때문이다.
센서 두 개가 한 개보다 훨씬 낫다. 한 손가락은 잘 닿고 있는데 반대편이 모서리만 살짝 걸친 경우, 단일 센서로는 못 잡아낸다. 두 면을 동시에 봐야 한다.
저데이터 영역에서는 vision + touch가 최고. 두 modality가 서로 다른 정보를 가지고 있다는 뜻이다.
대데이터 영역 (10만~100만)에서 새롭게 보이는 트렌드. 비전이 따라잡으며 계속 좋아진다. 실제 로봇으로는 도달할 수 없었던 데이터 영역인데, TACTO 덕분에 처음으로 들여다본 셈이다.

이 실험은 결과 자체보다 “100만 grasp을 하루 만에 모을 수 있다”는 사실 자체가 메시지다. tactile data scarcity가 학습 알고리즘 발전의 병목이었다면, 시뮬레이터가 이걸 푼다.

실험 2: 두 손가락 사이에서 구슬 굴리기

두 번째 실험은 제어 쪽이다. 위·아래 DIGIT 두 개 사이에 구슬을 끼우고, 위쪽 센서의 수평 위치를 제어해서 구슬을 원하는 목표 위치로 굴린다.

컨트롤러 형태

선형 피드백 컨트롤러:

\mathbf{u} = \mathbf{K} \, \bar{\mathbf{x}}, \quad \mathbf{u} \in \mathbb{R}^{2}, \; \bar{\mathbf{x}} = \mathbf{x} - \mathbf{x}^{*}, \; \mathbf{K} \in \mathbb{R}^{2 \times 2}

\mathbf{x}: 현재 구슬의 촉각 좌표 (tactile image에서 추정한 중심)
\mathbf{x}^{*}: 목표 위치
\mathbf{K}: 학습할 4개 파라미터

비용 함수는 누적 거리 오차 \sum_{t} \lVert \bar{\mathbf{x}}_t \rVert. 8방향 목표에 대해 평균을 낸다.

최적화 방법

베이지안 최적화 (UCB acquisition)로 \mathbf{K}를 찾는다. 50 iteration이면 충분하다.

실험이 보여주는 것

학습이 진행될수록 구슬을 더 빠르고 정확하게 목표로 굴린다 (논문 Fig. 11). 더 중요한 것은 수치 자체다. 50 iteration의 전체 실행 시간이 8분, 그 중 시뮬레이션 자체는 2분, 나머지 6분은 acquisition function 최적화. 50 iter × 8방향 × 50 step = 2만 장의 tactile imprint를 2분 안에 다 렌더링한다는 뜻이다.

이 정도면 강화학습에서 환경 스텝이 병목이 되지 않는다. 정책 업데이트 (gradient computation, replay buffer 등)가 더 무겁다.

실험 3: Sim2Real 자세 추정

세 번째 실험은 작지만 중요한 proof-of-concept다. DIGIT으로 작은 물체를 잡았을 때 그 자세를 추정하는 회귀 문제를 푼다. 시뮬레이션에서 학습한 모델을 실제 센서에 그대로 (또는 약간의 캘리브레이션을 거쳐) 적용한다.

논문 Table II의 핵심 결과를 풀어쓰면 이렇다.

Random baseline: position error 약 11.75 mm, rotation error 약 46.56°
Sim2Sim (학습·평가 모두 시뮬레이션): position 약 0.41 mm, rotation 약 3.48°
Real2Real (학습·평가 모두 실제, 16 datapoints): position 약 4.45 mm, rotation 약 21°대
Sim2Real (실제 캘리브레이션 후): position 4~5 mm 수준까지 좁힘

여기서 인사이트는 두 가지다. 첫째, 순수한 sim2real은 작동은 하지만 무시 못 할 gap이 있다. 비균일 조명, 노이즈, 캘리브레이션 차이가 누적된다. 둘째, 앞서 본 background calibration trick과 약간의 real data fine-tuning을 결합하면 gap이 빠르게 줄어든다. 즉 TACTO는 sim2real을 완벽히 해결하는 도구가 아니라, good initialization을 만드는 도구다. 정책의 사전학습 단계에서 막대한 시뮬 데이터를 쓰고, 마지막에 소량의 real data로 적응하는 게 권장 워크플로다.

비판적으로 보면

TACTO의 한계는 저자들이 솔직하게 적어둔 부분이 많고, 그 외에 실제로 써본 사람 입장에서 마주치는 지점들이 있다.

설계상 의도된 한계

접촉 경계의 변형 모델링이 없다. 두 메쉬가 그냥 겹치기 때문에, 젤이 모서리를 감싸는 부드러운 변형이 잡히지 않는다. 큐브의 가장자리에서 가장 두드러진다. 논문의 권장 우회로는 (1) 물체 메쉬 사전 스무딩, (2) 학습 후 GAN/diffusion 기반 보정인데, 둘 다 추가 작업이다.

강체 가정. 천, 종이, 두부 같은 변형체는 못 다룬다. PyBullet의 soft body 기능과 조합하면 어느 정도 가능하겠지만, 검증된 사용 사례는 적다.

광학 모델의 충실도. OpenGL의 표준 ray-tracing 기능에 의존하므로 Mitsuba2 같은 고급 렌더러보다는 광학적 사실성이 떨어진다. 굴절률이 다른 매질 (실리콘 젤과 공기 경계)에서의 부드러운 빛 분포 같은 효과는 한계가 있다.

실제 사용시 마주치는 디테일

해상도와 다손가락 환경의 trade-off. Allegro Hand에 DIGIT 4개를 다는 케이스가 50 FPS로 보고되어 있지만, 5손가락 humanoid에 더 큰 센서들을 다는 시나리오에서는 해상도를 낮추거나 비동기 렌더링이 필요해진다. Isaac Lab 같은 GPU-parallel 환경에서 envs 수를 늘리면 어떻게 되는지 별도 검증이 필요하다.

힘-변형 매핑의 단순성. piece-wise linear는 시작점으로는 충분하지만, 실제 실리콘은 strain-rate dependence와 hysteresis가 있다. 정밀 force estimation을 목표로 한다면 모자라다.

PyBullet의 접촉 모델 자체의 한계. TACTO 자체보다는 베이스 물리 엔진의 문제지만, in-hand manipulation처럼 접촉이 풍부한 시나리오에서 PyBullet의 강체 마찰 모델은 sim2real gap의 큰 원인이다. 이 점은 Isaac Lab (PhysX 5)이나 MuJoCo MJX 같은 GPU 기반 엔진과의 결합으로 일부 해소할 수 있다.

Sim2Real의 진짜 어려움은 정책 단계. 이미지 한 장의 sim2real은 background calibration으로 좁힐 수 있지만, time-series of contact (예: 미끄러짐, 회전) 차원에서는 PyBullet의 friction이 실제와 일치하지 않으면 정책이 망가진다. TACTO 단독으로 풀 문제는 아니다.

시뮬레이터	광학 모델	물리 엔진	속도	강점	약점
Gazebo + Phong (Gomes et al.)	Phong	Gazebo	보통	단순, Gazebo 친화	고급 광학 효과 어려움, 활발한 manipulation 검증 부족
Mitsuba2-based (Agarwal et al.)	Mitsuba2 ray-tracing	(느슨한 결합)	느림	매우 사실적	물리 엔진 통합 미흡
Unity-based	Unity 렌더러	Unity Physics	중간	시각적 디자인 자유	학술 워크플로와 거리
FEM-based	별도	FEM	매우 느림	변형 정확	실시간 학습 불가
TACTO	OpenGL/Pyrender	PyBullet (기본)	매우 빠름	속도·유연성·오픈소스	강체 가정, 접촉 경계 미세 디테일 약함

Allegro Hand 연구자 입장에서 본 활용 포인트

dexterous manipulation 연구를 하는 입장에서 TACTO를 어떻게 활용할지 정리하면 이렇다.

대규모 사전학습 데이터 생성. HORA, RotateIt, AnyRotate 같은 in-hand rotation 정책을 학습할 때, 촉각을 추가 modality로 넣는 ablation을 한다고 가정하자. 실제 DIGIT으로 데이터를 모으는 건 비현실적이지만 TACTO로는 며칠 안에 수백만 contact frame을 만들 수 있다. ResNet/ViT 기반 tactile encoder를 self-supervised로 사전학습시킬 데이터 소스가 된다.

Sim2Real bootstrap. tactile feedback 정책을 실제 Allegro Hand + DIGIT에 옮길 때, TACTO에서 사전학습한 정책을 시작점으로 삼고, 실제 데이터로 짧게 fine-tune하는 워크플로. background calibration trick은 한 손가락당 빈 이미지 한 장만 찍으면 되니 운영 비용이 거의 없다.

Isaac Lab 연구자에게는 통합 검증이 필요. TACTO는 PyBullet에 친화적으로 설계되어 있지만, Isaac Lab의 GPU-parallel envs 패러다임과는 자연스럽게 맞지 않는다. Isaac Lab에서 깊이 이미지를 뽑아 (선택지 B) TACTO로 RGB를 만드는 우회로는 가능하지만 I/O가 들어와서 속도가 떨어진다. 차라리 Taxim이나 새로 나오는 GPU-native tactile renderer를 검토하는 것이 답일 수 있다.

센서 설계 검토 도구로서. 사내에서 새로운 tactile sensor 모듈 (예: WIRobotics 자체 센서)을 프로토타이핑할 때, 광원 위치·카메라 시야각·젤 두께 같은 변수를 설정 파일에서 바꿔가며 가상으로 평가할 수 있다. 실제 제작 전에 design space를 좁히는 용도다.

FBA (Force-based Augmentation) 같은 추가 모듈. TACTO의 piece-wise linear deformation은 시작점일 뿐이다. ATI Mini45 같은 F/T 센서로 측정한 실제 hyperelastic 곡선을 사용자 함수로 끼워 넣으면, 자체 실리콘 컴파운드에 맞게 fine-tune할 수 있다.

핵심을 한 줄로 다시

TACTO의 진짜 기여는 “vision-based tactile sensor 시뮬레이션은 광학 문제다”라는 관점 전환이다. 물리 엔진을 다시 만드는 대신, 컴퓨터 그래픽스 도구를 정확한 위치에서 활용해 두 자릿수 배 빠른 시뮬레이터를 만들었다. 강체 가정과 단순한 변형 모델이라는 대가를 받아들였지만, 그 덕분에 100만 grasp 데이터를 하루에 모으는 일이 가능해졌다.

dexterous manipulation처럼 풍부한 접촉이 핵심인 분야에서, TACTO는 정확한 결말이 아니라 유용한 출발점이다. 학습용 사전학습 데이터를 만들고, 정책 구조를 빠르게 비교하고, 센서 설계를 검토하는 playground로 쓰는 게 맞다. 그 다음 실제 sim2real gap은 더 좋은 물리 엔진, 도메인 무작위화, 적은 양의 실제 데이터로 채워야 한다. 이 도구를 손에 쥔 채로 후속 연구를 따라가다 보면, vision-based tactile sensor가 왜 점점 더 진지한 연구 modality가 되어가는지 그 흐름이 보인다.