IMUDINO

IMUDINO

Turns motion-sensor recordings (accelerometer and gyroscope) into feature vectors with a PyTorch encoder. It suits researchers who build models on inertial sensor data.

Made by Octopus1 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: IMUDINO is a PyTorch encoder for IMU data, the readings from an accelerometer and a gyroscope. It reads a recording of all six sensor channels and returns feature vectors that other models can use. This repository holds the trained checkpoint, and the code lives in the project's GitHub repository.

Who it suits: It suits machine learning researchers and engineers who work with motion-sensor data and want ready-made features. You should be comfortable with Python and PyTorch.

Industry | Who uses it | How they use it | Example
Wearables | Sensor data engineers | Encode recordings from body-worn motion sensors into features | Turning a batch of recordings into vectors for a classifier
Research | Machine learning researchers | Use the encoder as a starting point for new models | Comparing its features against hand-made ones
Sports and health | Activity analysts | Feed the features to a model that labels movements | Grouping recordings by the kind of movement

People whose data is not motion-sensor data can skip it.

Where to use it:

• Python 3.10 or newer on Windows, macOS or Linux
• PyTorch with the timm package
• The project's GitHub repository, which holds the code and a runnable example

Use case | Who | What they get back
Feature extraction | ML researchers | A sequence vector, register vectors and one vector per time patch
Downstream modeling | Engineers | Features to feed into a classifier or other model

How to set it up:

• A Python 3.10 or newer environment
• PyTorch and timm, with the version the card names
• The code from the project's GitHub repository, plus the checkpoint file

1. Install PyTorch and timm.
2. Get the code from GitHub and download the checkpoint into it.
3. Load the checkpoint and set the model to evaluation mode.

pip install torch timm==1.0.30

huggingface-cli download Octopus1/IMUDINO imudino.pt --local-dir .

How to use it: Load the checkpoint into the model factory, switch to evaluation mode, and pass a dictionary with the IMU data, the sampling rates and an optional mask. The data holds accelerometer XYZ first, then gyroscope XYZ. The length must be a positive multiple of 16.

import torch
from model_factory import imuformer_huge_patch16

model = imuformer_huge_patch16()
model.load_state_dict(
    torch.load("imudino.pt", map_location="cpu", weights_only=True), strict=True
)
model.eval()

with torch.inference_mode():
    features = model({
        "imu_data": torch.randn(2, 1024, 6),
        "freqs": torch.tensor([100.0, 200.0]),
        "masks": None,
    })

Tool | What it does
cls_token | One vector for the whole sequence, shape [B, 768]
reg_tokens | Four register vectors per sequence, shape [B, 4, 768]
patch_tokens | One vector per time patch, shape [B, L / 16, 768]

Example: You pass a batch of two random recordings, each 1024 samples of six channels, sampled at 100 and 200 Hz. For this batch, the sequence vector has shape (2, 768) and the patch vectors have shape (2, 64, 768).

For newcomers and experts: An encoder turns raw sensor readings into a short list of numbers that a model can learn from. A first small step is to run the card's sample code with random data and check the output shapes.

The model splits input into patches of 16 samples and stacks 12 transformer layers with 24 attention heads each, plus 4 register tokens. All six channels are embedded together, and the positional encoding accounts for each sequence's sampling rate against a 100 Hz reference. Padded patches stay in the output, so exclude them when pooling.

Six-channel IMU recording plus its rate
Split into 16-sample patches
Transformer layers encode the patches
Sequence, register and patch vectors out

Good to know:

• License: GPL-3.0.
• Cost to run: none named. The steps need no API key or paid service.
• Data it reaches: it downloads the checkpoint from the Hugging Face Hub, and you fetch the code from GitHub. Your recordings stay in your own Python session.
• Not for: sequences whose length is not a multiple of 16.

Title: Encoder size
Transformer layers: 12 layers
Attention heads: 24 heads
Register tokens: 4 tokens

On Hugging Face, 13 November 2026

• Task: feature extraction
• Library: pytorch
• Downloads in the last 30 days: 0
• Likes: 3
• License: gpl-3.0
• Tags: pytorch, time-series, self-supervised-learning, dino, feature-extraction, encoder

Links

• Model: https://huggingface.co/Octopus1/IMUDINO
• Files: https://huggingface.co/Octopus1/IMUDINO/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download Octopus1/IMUDINO

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