ActionCodec2

ActionCodec2

Turns robot arm motion into compact tokens and back, in 34 ready-made tokenizer variants. For robotics researchers who train models that read and write robot actions.

Made by ZibinDong on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: ActionCodec2 is a tokenizer for robot actions. It converts a stretch of arm motion into a short list of tokens that a language-style model can learn, and it converts tokens back into motion. The card lists 34 variants that share one runtime and differ in precision and vocabulary size.

Who it suits: It suits robotics researchers who train vision-language-action models and need a way to turn continuous motion into tokens.

Industry | Who uses it | How they use it | Example
Robotics | Robot learning researchers | Tokenize arm trajectories for model training | Encoding a recorded pick-and-place motion
AI research | VLA model builders | Pick a variant with the precision and vocabulary budget they need | Comparing a 1 mm and a 10 mm variant
Simulation | Teams with recorded episodes | Fit their own tokenizer on their data | Training a tokenizer on their robot's episodes
Education | Students | Study how motion becomes tokens and back | Checking how lossy the round trip is

You can skip it if you are not working with robot actions, since this model does not process text, images or audio.

Where to use it:

• Python code that uses the transformers library with remote code allowed
• Windows, macOS or Linux, with Python for the download
• Training pipelines for robot policies, where the tokens feed a model

Use case | Who | What they get back
Encode robot actions | Researchers | A token sequence for a motion chunk
Decode tokens to motion | Policy builders | Reconstructed actions, which are lossy
Fit a custom tokenizer | Teams with their own data | A saved tokenizer built from their episodes

How to set it up:

• Python on your computer
• The packages numpy, scipy, torch, transformers 5.2 or newer below 6, huggingface-hub and pyyaml
• A choice of variant name, since the card lists many

1. Install the Python packages with pip.
2. Load the processor with a variant name and an action space.
3. Encode your actions, or decode tokens back.

pip install numpy scipy torch "transformers>=5.2,<6" huggingface-hub pyyaml

pip install -U huggingface_hub
hf download ZibinDong/ActionCodec2

How to use it: You load a codec by variant name, pass in actions shaped as time steps by dimensions, and get tokens back. The card's example uses one end-effector arm with seven values per step.

import numpy as np
from transformers import AutoProcessor
codec = AutoProcessor.from_pretrained(
    "ZibinDong/ActionCodec2", variant="paper-o1-5mm-4k-2bin-1p2ms",
    action_space="single_eef_delta", trust_remote_code=True,
)
actions = np.zeros((1, 16, 7), dtype=np.float32)
tokens = codec.encode(actions, fps=15)
restored = codec.decode(tokens, fps=15)

To train a tokenizer on your own episodes, the card gives these two lines.

codec.fit(episodes, fps=15)
codec.save_pretrained("./my-tokenizer")

Example: A researcher loads the paper variant and passes a chunk of 16 steps of arm motion. The codec returns tokens for the chunk. Decoding them gives back an approximation of the motion, since the card says reconstruction is lossy.

For newcomers and experts: If you are new to this, run the sample with zeros, then replace them with a recorded trajectory. Start with the paper variant the card uses before exploring the others.

If you know the field, the card describes first- and second-order tokenizers, three editions and per-profile vocabulary budgets from 1K up to 16K. Inputs are resampled to 15 Hz, rotations use rotation vectors and grippers are absolute open fractions. Dual arms are interleaved by time and tokens never merge across arms.

Choose a variant and action space
Pass in actions at a frame rate
The codec resamples to 15 Hz
It encodes the motion into tokens
Decode tokens back when needed

Good to know:

Edition | What it is
Paper | The pair of tokenizers the authors published with their paper, in two orders
Extended | Retrained after more data cleaning, with more precision and vocabulary choices
Sparse | Standard and high-dynamic first-order tokenizers with binary or 21-level grippers

• Limits: reconstruction is lossy, and absolute layouts also need the current state.
• Trust: loading uses remote code, so review it before you run it.
• Cleaning: it is off by default and only applies when fitting a tokenizer.
• License: Apache 2.0.
• Cost to run: none named.
• Data it reaches: it copies the files to your computer and processes only the action data you pass in.

On Hugging Face, 13 November 2026

• Task: robotics
• Library: transformers
• Downloads in the last 30 days: 217
• Likes: 3
• License: apache-2.0
• Tags: transformers, actioncodec2, robotics, action-tokenization

Links

• Model: https://huggingface.co/ZibinDong/ActionCodec2
• Files: https://huggingface.co/ZibinDong/ActionCodec2/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download ZibinDong/ActionCodec2

Then follow the usage in its model card. Nothing in this kit runs by itself.