🤖 machine learning

NeuralActuator: Neural Actuation Modeling for Robot Dynamics and External Force Perception

This paper introduces NeuralActuator, a neural actuator model trained on a newly collected dataset that jointly predicts simulator-equivalent torque surrogates, external contact forces, and motor health scores to address sim-to-real errors and enable sensorless force perception across diverse low-cost and high-end robotic platforms.

Original authors: Zhiyang Dou, John U. Onyemelukwe, Hangxing Zhang, Heng Zhang, Minghao Guo, Yunsheng Tian, Michal Piotr Lipiec, Joshua Jacob, Chao Liu, Peter Yichen Chen, Yuri Ivanov, Wojciech Matusik

Published 2026-07-14

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Zhiyang Dou, John U. Onyemelukwe, Hangxing Zhang, Heng Zhang, Minghao Guo, Yunsheng Tian, Michal Piotr Lipiec, Joshua Jacob, Chao Liu, Peter Yichen Chen, Yuri Ivanov, Wojciech Matusik

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you're trying to teach a robot arm to pick up a cup. You might think, "Easy! Just tell the motors how much power to send, and they'll push the arm exactly where you want." But for cheap, everyday robot arms, that simple math often fails. It's like trying to drive a car with a sticky steering wheel and a gas pedal that sometimes gets stuck; the relationship between what you tell the engine to do and what the car actually does gets messy because of friction, heat, and old gears.

Enter NeuralActuator, a new "brain" for robot motors that stops guessing and starts learning. Instead of assuming the motor is perfect, this system acts like a super-observant mechanic who watches the robot move, listens to the motor's hum, and feels the heat to figure out exactly what's happening.

The Problem: The "Sticky" Robot

Most robots, especially the affordable ones, rely on a simple rule: "More electricity equals more pushing power." But in the real world, cheap motors are messy. They have friction, they get hot, and they have tiny gaps in their gears (backlash) that make them sluggish. If you just tell a cheap robot to move, it might lag, shake, or push harder than you expect. This makes it hard to teach robots to do delicate tasks, like picking up an egg without crushing it, because the robot doesn't know how hard it's actually pushing.

The Solution: A "Magic" Translator

The researchers built NeuralActuator, a neural network (a type of AI) that acts as a translator between the robot's commands and its real-world movements. Think of it as a simulator's best friend.

Usually, to teach a robot, you need to know exactly how much force the motor is producing. But on cheap robots, you can't measure that force directly. So, the researchers came up with a clever trick: they let the robot's movement be the teacher.

They used a "differentiable simulator" (a super-smart video game engine that understands physics) to watch the robot move. If the robot moves slightly differently than the simulation predicted, the AI knows, "Oops, my guess about the motor was wrong." It then adjusts its internal map of how the motor behaves. It's like learning to ride a bike by watching where you actually go, rather than just guessing how hard you pedaled.

What It Can Do (The Magic Tricks)

Once trained, this AI doesn't just predict movement; it does three other cool things:

It "Feels" Without Hands: Even without special force sensors on its fingertips, NeuralActuator can guess when the robot is touching something. It's like having a sixth sense. If the robot bumps into a wall, the AI notices the motor struggling and says, "Hey, we're touching something!" It can even estimate how hard that push is. In tests, when the robot pushed a force gauge, the AI's guess was off by only about 0.015 to 0.037 Newtons (that's lighter than a small paperclip!).
It Checks the Motor's Health: The system can tell if a motor is acting weird. In one experiment, they tied rubber bands around a joint to make it harder to move. The AI spotted this "mechanical restriction" with 91.0% accuracy, noticing the motor was working harder than it should be, even though the robot was moving along the same path.
It Works on Any Budget: The team tested this on three very different robots:
- A tiny, cheap arm costing about $500.
- A mid-range arm.
- A fancy, industrial robot arm costing over $30,000.
  The AI learned to predict movements and forces accurately on all of them, proving it works whether the robot is a budget toy or a high-end machine.

How It Learned

To teach this AI, the researchers built a special "twin-arm" setup. One arm was controlled by a human (the leader), and the other arm (the follower) tried to copy the human's moves while holding weights or pushing against objects. They recorded everything: the commands sent, the motor's temperature, the electricity flowing, and the actual forces measured by sensors. This created a massive dataset called the Neural Actuation Dataset (NAD).

The AI learned by watching these recordings. It didn't just memorize the moves; it learned the story of the motor. It looked at the last few seconds of history (commands, speed, heat, and electricity) to predict what would happen next. It uses a "Transformer" architecture (the same kind of tech behind many modern AI chatbots) to understand how the robot's past actions affect its future.

The Results: Smarter, Safer Robots

When they put this AI to work, the results were impressive.

Better Control: When they used NeuralActuator to help a robot learn to pick up and place objects (a task called "behavior cloning"), the success rate jumped. For a "pick-and-place" task, the robot succeeded 92.5% of the time with the AI, compared to only 80% without it.
Fast Thinking: The AI is incredibly fast. It can make decisions in 0.25 milliseconds on a graphics card, which is fast enough to keep up with a robot moving at 60 times per second.
No Magic Sensors Needed: The coolest part is that it doesn't need expensive force sensors to know when it's touching something. It figures it out just by listening to the motors.

What It's Not (The Limits)

It's important to know what this AI doesn't do.

It's not a crystal ball for the future: The AI predicts what happens based on what the robot just did. It can't guess what would happen if you gave it a completely different command it hasn't seen before, unless you also have a model for how the motor would react to that new command.
It's not perfect forever: If the robot gets really old or the environment changes drastically, the AI might get a little "drifty" over long periods. However, the researchers showed that you can quickly "fine-tune" it with just 12 new movement examples (taking about 356 seconds) to get it back on track.
It's a guess, not a direct measurement: On the cheap robots, the AI is predicting a "surrogate" (a stand-in) for the force. It's not measuring the exact physics of the motor in a lab; it's learning a pattern that works so well it acts like the real thing.

The Bottom Line

NeuralActuator is a big step forward for making robots smarter and more affordable. By teaching robots to understand their own motors and "feel" their surroundings without expensive sensors, it opens the door for cheaper robots to do delicate, real-world tasks like lifting objects, pushing buttons, or working alongside humans. It turns a robot that just blindly follows orders into one that actually understands how it moves.

Technical Summary: NeuralActuator

Problem Statement

Differentiable simulators have advanced robot control, yet actuator dynamics remain a significant source of sim-to-real error, particularly on low-cost platforms. Standard control approximations assume a linear relationship between motor current and joint torque ( $\tau = K_t I$ ). However, on cost-effective, servo-driven platforms (e.g., coreless brushed DC servos), this approximation fails due to unmodeled non-idealities such as gearbox friction, hysteresis, backlash, current saturation, and thermal drift. These time-varying effects are difficult to model analytically because internal transmission states are inaccessible. Consequently, relying on linear current-to-torque mappings leads to poor effort tracking, unstable impedance behavior, and degraded force perception, especially when dedicated force/torque sensors are unavailable.

Methodology

The authors propose NeuralActuator, a data-driven, differentiable neural model that jointly predicts actuator behavior and external interactions.

1. Architecture and Inputs

NeuralActuator utilizes a Transformer-based architecture to capture temporal dependencies and nonlinear, history-dependent actuator dynamics.

Input Sequence: At each time step $t$ , the model processes a sequence of nine tokens ( $H_{hist} + 1$ ), comprising commanded targets, proprioceptive states (positions, velocities), and actuator telemetry (current, voltage, temperature).
Multi-Task Heads: The Transformer encoder feeds four distinct output heads:
1. Torque-Surrogate Head: Predicts a simulator-equivalent generalized-effort surrogate ( $\tau_{pred}$ ). This is not a direct physical torque measurement but a value that, when fed into a differentiable simulator, reproduces the observed motion.
2. Force Head: Predicts a raw 3D external force vector ( $\hat{f}_{raw}$ ).
3. Contact Gate: Predicts a contact probability ( $g \in [0, 1]$ ) to gate the force output ( $\hat{f} = g \cdot \hat{f}_{raw}$ ).
4. Motor-Condition Head: Predicts a score indicating normal vs. mechanically restricted operation for specific joints.

2. Training Strategy

A key innovation is the supervision scheme, which avoids the need for direct generalized-effort labels (torque) on low-cost platforms where they are unreliable.

Torque-Surrogate Supervision: The torque-surrogate head is trained via differentiable simulation. The predicted surrogate is clipped and fed into a differentiable physics engine (MuJoCo/MJX). The loss is computed based on the discrepancy between the simulated trajectory (future poses) and the real-robot recorded trajectory. This allows the model to learn the effective input required to match dynamics without assuming a fixed current-to-torque conversion.
Direct Supervision: The force, contact gate, and motor-condition heads are trained using direct labels (force sensor readings, contact events, and known mechanical restrictions).
Dataset (NAD): The authors introduce the Neural Actuation Dataset (NAD), collected via a twin-arm teleoperation system. It includes synchronized robot states, actuator telemetry, and external force labels across free motion, payload handling, and contact interactions.

3. Integration

The model is integrated into the simulation loop for end-to-end training. During inference, the torque surrogate drives the simulator for trajectory propagation, while the force and condition heads provide auxiliary outputs for perception and diagnostics.

Key Contributions

NeuralActuator Model: A differentiable, multi-task neural actuator model that predicts simulator-equivalent torque surrogates, external forces, contact probabilities, and motor health scores without requiring direct torque sensors.
Training via Differentiable Physics: A novel training scheme where the torque surrogate is supervised by pose trajectories through differentiable simulation, bypassing the need for unreliable current-to-torque calibration.
Neural Actuation Dataset (NAD): A real-robot dataset featuring time-aligned robot states, actuator telemetry, and end-effector external-force labels, collected via a custom twin-arm teleoperation system.
Cross-Platform Validation: Comprehensive evaluation across three distinct platforms spanning a wide cost range ($500 to $30,000+):
- OpenManipulator-X: 5-DoF, low-cost, servo-driven.
- SO-101: 6-DoF, low-cost, LeRobot stack.
- Franka Emika Panda: 7-DoF, industrial-grade.

Experimental Results

The paper validates NeuralActuator across several benchmarks:

Rollout Accuracy: On the OpenManipulator-X, the model achieves low mean absolute errors (MAE) in joint angles (e.g., ~2.5°–3.1° at 600 steps) and gripper positions, outperforming baselines over long horizons.
Force Estimation:
- Contact Detection: Achieves low force MAE (0.36–0.57 N) on contact trajectories and near-zero predictions on non-contact trajectories.
- Payload Benchmarks: Accurately estimates gravitational loads (0.08–0.12 N MAE) across various weights (200g–500g).
- Comparison: Outperforms model-based baselines (Inverse Dynamics with linear friction, Stribeck friction, and Generalized Momentum Observer) by a significant margin (e.g., 0.12 N vs. 0.66 N MAE for the best baseline).
Motor Condition Estimation: Achieves 91.0% accuracy and 0.95 AUC-ROC in distinguishing between normal and mechanically restricted (rubber-band constrained) joint operation, significantly outperforming threshold, SVM, and Random Forest baselines.
Downstream Control: When used as a frozen pre-trained module for behavior cloning, the force-aware policy improves task success rates (e.g., 92.5% vs. 80% for pick-and-place) compared to position-only baselines.
Efficiency: The implementation achieves sub-millisecond GPU inference (0.25 ms mean time) at 60 Hz control rates with a modest parameter footprint (1.44M parameters).

Significance and Claims

The paper claims that NeuralActuator addresses a critical gap in low-cost robotics by providing a robust, data-driven alternative to analytical actuator modeling. Its significance lies in:

Enabling Force Perception without Sensors: It allows low-cost robots to perceive external forces and contacts using only standard telemetry (current, voltage, temperature) and proprioception, removing the cost barrier of force/torque sensors.
Bridging Sim-to-Real: By learning a history-dependent mapping that accounts for friction, backlash, and thermal effects, it improves the fidelity of differentiable simulations for low-cost hardware.
Scalability: The approach is validated across diverse actuator families and price points, suggesting it is a generalizable solution for the growing ecosystem of affordable robotic platforms.
Diagnostic Capability: The ability to detect mechanical restrictions (e.g., jammed joints) without additional hardware adds a layer of reliability and maintenance capability to robotic systems.

The authors note limitations, including the accumulation of error in long-horizon recorded-telemetry-conditioned rollouts and the current inability to perform counterfactual planning without an additional effort-response model. However, they demonstrate that online adaptation can mitigate drift, and the model effectively supports real-world manipulation tasks.