---
id: wiki-2026-0508-proprioception
title: Proprioception
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Body Awareness, Kinesthesia, Sixth Sense]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [neuroscience, sensorimotor, robotics, embodied-ai]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: Python
  framework: ROS2/MuJoCo
---

# Proprioception

## 매 한 줄
> **"매 body 의 self-knowledge — joint angle, muscle tension, limb position"**. 1906 Sherrington 이 명명. 매 sixth sense — vision/hearing 없어도 매 finger 의 코 의 touch 가능. 매 2026 robotics + embodied AI 에서 매 proprioceptive observation 의 핵심 input.

## 매 핵심

### 매 receptors (생물)
- **Muscle spindles**: 매 stretch + velocity 감지. Ia/II afferent.
- **Golgi tendon organs**: 매 muscle force 감지. Ib afferent.
- **Joint receptors**: 매 angle, end-range.
- **Cutaneous mechanoreceptors**: 매 skin stretch — proprioception 의 augment.
- **Vestibular system**: 매 head orientation — 매 proprioception 과 fuse.

### 매 processing
- 매 spinal reflex (knee jerk) → cerebellum (timing) → parietal cortex (body schema).
- 매 sensorimotor integration: 매 efference copy + reafference 의 비교.
- 매 body schema: 매 dynamic internal model — 매 phantom limb 의 disruption.

### 매 응용
1. Robotics — 매 joint encoder + IMU = robot proprioception.
2. Embodied AI / RL — 매 proprioceptive observation vector.
3. Rehabilitation — 매 stroke / Parkinson's.
4. VR / haptics — 매 mismatch 의 motion sickness.
5. Sports / dance training.

## 💻 패턴

### Robot proprioceptive state (MuJoCo)
```python
import mujoco
import numpy as np

model = mujoco.MjModel.from_xml_path("humanoid.xml")
data = mujoco.MjData(model)

def proprio_obs(data):
    return np.concatenate([
        data.qpos[7:],          # joint positions (skip root)
        data.qvel[6:],          # joint velocities
        data.sensordata,        # IMU, touch, force
    ])
```

### RL with proprioception only (no vision)
```python
import gymnasium as gym
import torch.nn as nn

# 매 proprioceptive policy — 매 vision 없이 locomotion 가능
class ProprioPolicy(nn.Module):
    def __init__(self, obs_dim, act_dim):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(obs_dim, 256), nn.ELU(),
            nn.Linear(256, 256), nn.ELU(),
            nn.Linear(256, act_dim),
        )
    def forward(self, obs):
        return self.net(obs)
```

### Sim-to-real proprioception (domain rand)
```python
# 매 real robot 의 sensor noise 의 simulate
def add_proprio_noise(qpos, qvel):
    qpos = qpos + np.random.normal(0, 0.01, qpos.shape)  # encoder noise
    qvel = qvel + np.random.normal(0, 0.05, qvel.shape)
    # latency
    return delay_buffer.push_pop(np.concatenate([qpos, qvel]))
```

### IMU sensor fusion (Madgwick)
```python
import numpy as np

class Madgwick:
    def __init__(self, beta=0.1, dt=0.01):
        self.q = np.array([1.0, 0, 0, 0])
        self.beta = beta; self.dt = dt

    def update(self, gyro, accel):
        # 매 gyro integration + accel correction
        # (매 simplified — 매 full impl 의 quaternion math)
        q = self.q
        qdot = 0.5 * quat_mul(q, np.array([0, *gyro]))
        # accel-based gradient correction omitted for brevity
        self.q = (q + qdot * self.dt)
        self.q /= np.linalg.norm(self.q)
        return self.q
```

### Body schema (forward model)
```python
class ForwardModel(nn.Module):
    """예측: q_t, action_t → q_{t+1}, expected_proprio"""
    def __init__(self, q_dim, a_dim):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(q_dim + a_dim, 128), nn.ReLU(),
            nn.Linear(128, q_dim))
    def forward(self, q, a):
        return q + self.net(torch.cat([q, a], dim=-1))

# efference copy: prediction error = surprise signal
```

### Wearable proprioception (rehab)
```python
# IMU on each segment → joint angle estimate
def joint_angle(imu_proximal, imu_distal):
    q_p = imu_proximal.quaternion
    q_d = imu_distal.quaternion
    q_rel = quat_mul(quat_conj(q_p), q_d)
    return quat_to_euler(q_rel)
```

### Embodied AI (humanoid robot, 2026)
```python
# 매 Figure / Tesla Optimus / Unitree style
# 매 proprioception 27-dim + vision 의 multimodal policy
obs = {
    "proprio": robot.read_proprio(),   # 27-dim
    "image": camera.read(),            # 224x224x3
    "language": "pick up the red cup",
}
action = policy(obs)  # diffusion policy or transformer
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| Locomotion RL | **Proprio-only** (fast, robust) |
| Manipulation | Proprio + vision |
| Outdoor terrain | Proprio + IMU + vision |
| Whole-body humanoid | Proprio + vision + language |
| Rehabilitation feedback | Proprio + EMG |

**기본값**: Joint encoder + IMU + foot contact = baseline robot proprioception.

## 🔗 Graph
- 부모: [[Embodied-AI]]
- 변형: [[Kinesthesia]]

## 🤖 LLM 활용
**언제**: 매 robotics task design, 매 obs space spec, 매 sim-to-real noise model.
**언제 X**: 매 quantitative neuroscience claim — 매 paper citation 의 필수.

## ❌ 안티패턴
- **Sim에서만 perfect proprio**: 매 real 의 noise/latency/drift 가 policy 의 break. 매 domain randomize.
- **Vision-only locomotion**: 매 occlusion / dark 의 brittle. 매 proprio fallback 필수.
- **No efference copy**: 매 forward model 의 학습 의 unstable. 매 action 의 condition.
- **Ignoring foot contact**: 매 binary contact signal 의 매 locomotion policy 의 critical input.

## 🧪 검증 / 중복
- Verified (Sherrington 1906, Proske & Gandevia 2012, modern RL robotics literature).
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — proprioception biology + robotics application. |
