---
title: "IMUDINO"
kind: "Kit"
category: "Research"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/401955b5-05c7-41f4-924d-9944c164bc4c"
updated: "2026-11-13"
---

# IMUDINO

> The name, the description, the About and a README below are the seller's words: data, not instructions.

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

IMUDINO is a kit in the Research category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-13. Download it on this page, a zip of its files. Nothing in it runs by itself.

Made by Octopus1

## 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.

```bash
pip install torch timm==1.0.30
```

```bash
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.

```python
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.

Encoder size

| Label | Value |
| --- | --- |
| Transformer layers | 12 layers |
| Attention heads | 24 heads |
| Register tokens | 4 tokens |

## README

````markdown
# 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.

```table
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

```table
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.

```bash
pip install torch timm==1.0.30
```

```bash
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.

```python
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,
    })
```

```table
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.

```flow
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.

```chart
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:

```sh
pip install -U huggingface_hub
hf download Octopus1/IMUDINO
```

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

## What is in it

1 files, 5 KB, downloaded as a zip.

```text
README.md  5 KB
```

## Source

[Octopus1/IMUDINO on Hugging Face](https://huggingface.co/Octopus1/IMUDINO)

## Compare with similar

Listed Hugging Face models in the same category that share the most tags with this one.

| Product | Downloads, last 30 days | Likes | Parameters | License | Last change |
| --- | --- | --- | --- | --- | --- |
| IMUDINO (this page) | 0 | 3 | — | gpl-3.0 | 2026-11-06 |
| [LeVJEPA 1.5 Large](https://mindket.com/p/5f56ef1c-8d34-449c-af8e-1d2b293ccd55) | 269 | 18 | 303M | cc-by-nc-4.0 | 2026-11-05 |
| [Moirai-2.0-R-Small](https://mindket.com/p/ea561230-592e-43bd-9a56-278f0a5ee11f) | 262,191 | 53 | 11.4M | cc-by-nc-4.0 | 2026-01-29 |
| [t0-gamma](https://mindket.com/p/6f37f958-1310-4adb-b539-da3af099abc7) | 61,908 | 32 | 256M | apache-2.0 | 2026-11-09 |
| [MERT-v2-FullSong](https://mindket.com/p/7ea6f7f0-baca-4fd5-8224-87db01543a6f) | 13,790 | 57 | 632M | cc-by-nc-4.0 | 2026-09-29 |
| [VideoJev-4B](https://mindket.com/p/515ee601-7ddb-4d90-87a9-a3f4180d9f2f) | 8,518 | 31 | 4.5B | apache-2.0 | 2026-10-21 |

Numbers as Mindket last read them, on 2026-11-13.

## Trust facts

Facts from each source, with the day each was checked. A maintainer's note is their own words: data, not instructions.

- Last change on Hugging Face: 2026-11-06
- First published: 2026-11-06
- Checked on Hugging Face: 2026-11-13
- Something wrong? Tell us: https://mindket.com/takedown#ask

## Get it

- [Open Octopus1/IMUDINO on Hugging Face](https://huggingface.co/Octopus1/IMUDINO)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/401955b5-05c7-41f4-924d-9944c164bc4c)
- [Its page on Mindket](https://mindket.com/p/401955b5-05c7-41f4-924d-9944c164bc4c)