lingbot-touch-small

lingbot-touch-small

Turns tactile sensor readings from magnetic, piezoresistive and visuotactile sensors into learned features for robot manipulation. For robotics researchers who already have a compatible inference setup.

Made by robbyant 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: LingBot-Touch-Small is a tactile representation model for robot hands. It takes touch readings from magnetic, piezoresistive and visuotactile sensors and turns them into learned features. It uses a separate tokenizer for each sensor type and one shared Transformer, and it learns by predicting in latent space.

Who it suits: It suits robotics researchers and engineers who work with fingertip touch sensors and want features for perception and manipulation.

Industry | Who uses it | How they use it | Example
Robotics | Robot hand developers | Turn touch readings into learned features | Feeding fingertip sensor data to a grasp planner
Tactile research | Researchers | Compare three sensor types with one model | Testing one encoder on magnetic and piezoresistive data
Sensor hardware | Sensor makers | Check how a new sensor fits the shared input layout | Adapting a sensor's geometry to the expected shape
Manipulation learning | Policy developers | Read the features in a downstream task | Querying the features with attention for a task head

You can skip it if you want a ready-to-run package, since this repository holds weights and a configuration but no inference code.

Where to use it:

• The separate LingBot-Touch inference implementation, which the card says is distributed on its own
• Windows, macOS or Linux with Python, to download the files
• Setups with five-finger hands, since the input layout lists thumb, index, middle, ring and pinky

Use case | Who | What they get back
Tactile perception | Robotics teams | Latent features from touch signals
Robot manipulation | Policy developers | Features that a task head can read
Sensor comparison | Researchers | One encoder across three sensor types

How to set it up: You need Python for the download tool and the separate inference implementation. This repository gives you the weights and their matching configuration, nothing more.

• Python on Windows, macOS or Linux
• The huggingface_hub package
• The compatible LingBot-Touch inference code, obtained separately
• Sensor data adapted to the expected input shape

1. Install huggingface_hub.
2. Download the model files.
3. Keep encoder.pt and config.json together and load them with the inference code.

pip install -U huggingface_hub
hf download robbyant/lingbot-touch-small

How to use it: The visible card shows no run command, because the repository ships no inference code. The encoder takes normalized touch signals, taxel coordinates and a choice of sensing type. It returns latent features with their time, finger and spatial addresses. The card recommends attention-based querying to read out a task.

File | What it holds
encoder.pt | The parameter tensors of the frozen target encoder
config.json | The inference architecture and the modality routes

Example: You feed normalized fingertip readings for all five fingers, choose the magnetic sensing type, and run the encoder. It gives back token-level latent features that a downstream grasping model can query.

For newcomers and experts: If you are new to this, picture a robot fingertip that can feel pressure. This model turns raw touch numbers into a compact set of features that a robot program can use. A first small try is only the download step, since running it needs the separate inference code.

For people who know the field, the model is JEPA-based, so it predicts in latent space instead of reconstructing raw signals. Magnetic data keeps three axes. Piezoresistive readings and decoded visuotactile values sit in the Z channel while X and Y stay at zero. Raw camera pictures are not accepted as input.

Touch readings are normalized to the input shape
A tokenizer for the sensor type makes tokens
A shared Transformer encodes them
You get latent features with finger and spatial addresses

Good to know: Before inference, you must convert the sensor layout, hand side, point order and value ranges to what the encoder expects. The repository has no sensor adapters, sample datasets or training files.

• License: Apache 2.0
• Cost to run: none named
• Data it reaches: the touch signals you feed it, plus the downloaded files
• Not for: use without the separate inference code, or with raw RGB images as input

On Hugging Face, 13 November 2026

• Task: robotics
• Downloads in the last 30 days: 309
• Likes: 10
• License: apache-2.0
• Tags: tactile, robotics, representation-learning

Links

• Model: https://huggingface.co/robbyant/lingbot-touch-small
• Files: https://huggingface.co/robbyant/lingbot-touch-small/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download robbyant/lingbot-touch-small

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