💻 computer science

Kine2Go: Kinematic dataset for the Unitree Go2 robot with diverse gaits and motions

This paper introduces Kine2Go, a comprehensive kinematic dataset featuring 800 diverse gait trajectories and corresponding motor actions for the Unitree Go2 robot, generated through a pipeline that adapts various quadruped morphologies and utilizes reinforcement learning to produce robust, perturbed demonstration data for machine learning applications.

Original authors: Władysław Pałucki, Paweł Siwak, Krzysztof Ciebiera, Marek Cygan

Published 2026-06-15

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Władysław Pałucki, Paweł Siwak, Krzysztof Ciebiera, Marek Cygan

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

The Big Picture: Teaching a Robot Dog to Dance

Imagine you have a brand-new, high-tech robot dog (the Unitree Go2). You want it to run, trot, spin, and walk like a real animal. But the robot doesn't know how to do these things naturally. If you just tell it "move," it might flail its legs, trip over itself, or move in a jerky, unnatural way.

To teach it, you need a teacher. In the world of robotics, this teacher is usually a dataset—a massive library of "correct" movements that the robot can copy.

The problem? While we have huge libraries of human dance moves and human walking data, we didn't have a good library for robot dogs. Most existing data was either for real animals (which have different body shapes than robots) or for other robots that move differently.

Kine2Go is the solution. It is a new, massive library of 800 different movement patterns specifically designed for the Unitree Go2 robot. It's like a "Greatest Hits" album of robot dog gaits, ready for researchers to download and use.

How They Built It: The "Translation and Practice" Pipeline

The authors didn't just film a robot dog running. They built a three-step assembly line to create this data:

1. The Translator (Kinematic Retargeting)

Imagine you have a video of a real horse galloping or a real dog trotting. You can't just play that video on a robot dog because a horse has 4 legs but a different bone structure than a robot.

The Analogy: Think of this like subtitling a movie. The original movie (the animal motion) is in a foreign language (horse anatomy). The team built a translator that converts those movements into the robot's native language (Go2 anatomy).
The Result: They took motion data from real dogs, horses, and even another robot (Solo8) and mathematically "remapped" it so it fits the Unitree Go2's specific joints and leg lengths.

2. The Coach (Reinforcement Learning)

Once they had the "remapped" movements, they still weren't perfect. The robot might know where to put its foot, but not how to get there smoothly.

The Analogy: Imagine a dance student who has the choreography written down but has never practiced. If they try to dance, they might stumble. The authors used Reinforcement Learning (RL) as a super-fast coach.
How it worked: They created a virtual gym (using a physics engine called Genesis) where they ran 8,192 simulations at the same time. The robot tried to copy the "translated" dance moves millions of times. Every time it stumbled, the coach gave it a "bad grade." Every time it moved smoothly, it got a "good grade."
The Outcome: The robot learned the muscle memory needed to perform those moves naturally, including the specific motor commands (how much to turn each joint) required to stay balanced.

3. The Recording Studio (Data Gathering)

Once the robot had learned the moves, the team recorded the final performance.

The Analogy: This is like recording the final concert. They didn't just record the dance moves; they recorded everything: where the robot's body was, how fast it was spinning, where every joint was, and exactly what electrical signals (motor commands) it sent to its legs to make it happen.
Quality Control: They watched the videos and threw out any recordings where the robot fell over or crashed. They kept only the smooth, stable, "gold-standard" performances.

What's Inside the Dataset?

The final product, Kine2Go, contains 800 unique trajectories (paths of movement) derived from 40 different "songs" or motion styles.

The Variety: It includes walking, running, trotting, turning in circles, moving in figure-eights, and even some complex maneuvers like "strafing" (moving sideways).
The Sources: They pulled inspiration from four different places:
1. Real Dogs: Motion capture data from actual dogs.
2. Real Horses: Data from horses trotting and walking.
3. Another Robot: Data from a different robot called Solo8 (which has a slightly different body shape, making it a tough test for their translator).
4. A Video Game: They used a simulation where a user could control a digital wolf to create complex paths like squares and ellipses.

Why Does This Matter?

The paper argues that for robots to move naturally, they need to learn from diverse examples, not just one specific trick.

The "Foundation Model" Idea: In the past, researchers trained a robot to do one thing (like walk forward). Now, the goal is to train a "foundation model"—a robot brain that can understand a wide variety of movements and switch between them based on what you ask it to do.
The Missing Piece: You can't build a smart robot brain without a big library of examples to learn from. Kine2Go provides that library for quadruped (four-legged) robots, filling a gap that previously existed because most big datasets were for humans.

What They Didn't Do (Limitations)

The authors are honest about what is missing from their library:

No Jumping: They tried to teach the robot to jump, but the robot kept falling. So, they left jumps out of the dataset.
No Sitting: Real dogs can sit, but the robot's legs are shaped differently. If they tried to make the robot "sit" based on a dog's motion, its knees would end up underground. They skipped this to avoid broken simulations.
Flat Ground Only: All the data is for flat floors. They didn't test the robot on stairs or rocky terrain yet.

Summary

Kine2Go is a toolkit for robot researchers. It takes messy, real-world animal movements, translates them into a robot's language, teaches a robot how to perform them perfectly using a super-fast virtual coach, and then saves the results. This allows other scientists to skip the hard work of collecting data and jump straight to building smarter, more agile robot dogs.

Technical Summary: Kine2Go

Problem Statement

The rapid advancement of robotics, particularly with affordable hardware like the Unitree Go2 quadruped, has spurred interest in using machine learning (ML) techniques such as Reinforcement Learning (RL) and behavioral cloning for locomotion control. However, a significant bottleneck exists: obtaining high-quality demonstration data is difficult. While ML methods often require kinematic trajectories and corresponding motor-level actions to train robust policies, generating this data typically demands complex pipelines and significant time.

Furthermore, while large-scale motion capture (MoCap) datasets exist for humanoids (e.g., Human3.6M, AMASS) and some animal species, there is a lack of comparable, open-source resources for quadrupedal robots. Existing quadruped datasets often lack the specific state-action rollouts required for low-level control learning. Additionally, RL-based control often struggles to produce smooth, natural, and symmetric gaits without extensive reward shaping, which is prone to reward hacking and requires tedious trial-and-error. Current motion imitation approaches often rely on single-policies for single motions, limiting the ability to create general, foundational policies capable of diverse gaits.

Methodology

The authors present Kine2Go, a dataset and pipeline designed to bridge the gap between raw motion data and actionable RL policies for the Unitree Go2 robot. The methodology consists of three primary stages implemented within the Genesis physics engine, a high-performance, GPU-accelerated simulator:

Kinematic Retargeting:
- The pipeline ingests motion capture data from diverse source morphologies (dogs, horses, and other robots).
- A modular retargeting process maps these source motions onto the specific 12-DoF kinematic structure of the Unitree Go2.
- An Inverse Kinematics (IK) solver resolves joint configurations frame-by-frame, treating retargeted foot positions as task-space objectives to ensure the motions remain within the robot's reachable workspace.
- The output is a continuous, robot-compliant reference trajectory containing pose information but no action data.
Reinforcement Learning Motion Imitation:
- For each retargeted reference trajectory, a dedicated control policy is trained using a goal-conditioned Markov Decision Process (MDP).
- The objective is to minimize the tracking error between the simulated robot's state and the reference motion.
- Observation Space: Includes proprioceptive states (joint positions/velocities, base orientation) and future reference states sampled at $t+1, t+2, t+10,$ and $t+30$ .
- Reward Function: A weighted sum of terms penalizing deviations in root position, linear/angular velocities, joint configurations, and end-effector positions.
- Training: The Proximal Policy Optimization (PPO) algorithm is used within the Genesis engine, leveraging massive parallelism (8,192 environments) to train each policy for approximately 2 billion steps over 10,000 iterations.
Trajectory Gathering and Filtering:
- Once policies converge, stochastic rollouts are executed to generate the final dataset.
- Each rollout is initialized with randomized heading orientations to maximize state-space diversity.
- Data recorded includes joint configurations, base kinematics (quaternion orientation, angular velocity), control actions (normalized motor commands), and global states.
- Quality Control: Trajectories are rendered into high-resolution videos and manually inspected to filter out unstable behaviors (collisions, falls, tracking divergence). The first 0.5 seconds of each trajectory are trimmed to remove "warmup" frames where the policy synchronizes with the reference.

Key Contributions

Kine2Go Dataset: A comprehensive dataset comprising 800 diverse motion trajectories for the Unitree Go2 robot. The data is derived from 40 distinct RL policies, each optimized for a unique reference motion.
Diverse Source Morphologies: The dataset integrates data from four distinct sources:
- AI4Animation: Dog motion capture data (walking, running, turning).
- VHDC: Horse motion capture data (trot, walk).
- Solo8: Data from a different quadruped robot morphology (8-DoF), providing challenging motions like crawling and jumping.
- AI4Animation Interactive Demo: User-controlled wolf simulations generating complex paths (ellipses, loops, squares).
State-Action Rollouts: Unlike pure kinematic datasets, Kine2Go provides the corresponding motor-level actions required to reproduce the motions, making it directly applicable to behavioral cloning and offline control.
Scalable Pipeline: The authors release a pipeline built on the Genesis engine that allows researchers to easily extend the dataset with new sources or adapt the approach to other quadruped morphologies. The pipeline is optimized for consumer-grade GPUs, democratizing robotic data generation.

Results

The resulting dataset covers a broad spectrum of locomotive motions, including walking, running, trotting, turning, spinning, and complex path following (circles, squares, ellipses).

Scale: 800 trajectories generated from 40 policies, with each policy producing 20 independent trajectories characterized by randomized initial headings.
Coverage: The dataset includes motions ranging from 5 to 20 seconds in duration, capturing at least one full cycle of each gait.
Data Structure: Each frame contains joint positions/velocities, base orientation/velocity, and normalized motor commands.
Limitations: The authors note that motions involving jumps (where all legs leave the ground) were excluded due to poor imitation quality. Sitting motions were also excluded due to morphological incompatibility (elbows below ground level) requiring manual frame-by-frame correction. All data is collected on flat terrain, and foot pressure sensor data is not simulated.

Significance and Claims

The paper positions Kine2Go as a foundational resource for the quadruped robotics community, analogous to how AMASS or MoCapAct serve humanoid research.

Lowering Barriers: By providing an "off-the-shelf" solution of high-fidelity kinematic and action data, the dataset lowers the entry barrier for advanced motion research, removing the need for researchers to build complex data collection pipelines.
Enabling Foundational Models: The primary intended use is to train and regularize behavioral foundational models. The authors argue that while simple behavioral cloning can be evaluated via Mean Squared Error (MSE), foundational models require diverse datasets to learn general characteristics of motion rather than just mimicking specific trajectories. Kine2Go aims to support the development of policies that can switch between gaits based on commands, moving beyond single-motion policies.
Simulation to Reality: The dataset is designed to facilitate the training of models in simulation that can be regularized with Kine2Go and eventually deployed to the real world to evaluate robustness.
Democratization: The use of the Genesis engine and the pipeline's efficiency on consumer-grade hardware aims to democratize the generation of robotic data, allowing smaller research groups to experiment with diverse gaits and morphologies without access to supercomputing clusters.

The authors modestly claim that while the dataset addresses a critical gap in quadruped research, the evaluation of complex foundational models remains an open area of study, and future work will focus on expanding the dataset to include acrobatic maneuvers and rough terrain navigation.