Datasets:

Tachintech
/

tactile-deformation-response

pretty_name: Tactile Deformation Response Dataset
language:
  - en
license: gpl-3.0
task_categories:
  - robotics
tags:
  - tactile-sensing
  - electronic-skin
  - deformation-response
  - tactile-time-series
  - time-series-classification
  - inary-classification
  - npz
  - robotics
size_categories:
  - n<1K
configs:
  - config_name: default
    data_files:
      - split: train
        path: metadata/train.jsonl
      - split: validation
        path: metadata/validation.jsonl
      - split: test
        path: metadata/test.jsonl

Tactile Deformation Response Dataset

Dataset Summary

This dataset contains tactile array time-series samples collected from a 32 × 32 tactile sensor. Each sample is represented by a fixed-length sequence of base-corrected tactile response frames and paired with a JSON metadata file. The primary task is binary deformation response classification: rigid versus deformable.

The dataset is intended for research on tactile perception, contact response modeling, material interaction analysis, and neural network models for tactile sequence classification.

Repository Structure

data/
├── train/
│   ├── *.npz
│   └── *.json
├── validation/
│   ├── *.npz
│   └── *.json
└── test/
    ├── *.npz
    └── *.json

metadata/
├── train.jsonl
├── validation.jsonl
└── test.jsonl

scripts/
├── validate_dataset.py
├── build_metadata.py
└── load_sample.py

The .npz files contain the tactile sequence data. The paired .json files contain sample-level metadata and labels. The metadata/*.jsonl files provide split-level index files for Hugging Face loading and dataset preview.

Data Files

Each sample consists of one .npz file and one .json file with the same base filename.

Example:

20260721_162148_819725_Silicone_cube_deformable_10.npz
20260721_162148_819725_Silicone_cube_deformable_10.json

The JSON metadata should contain:

{
  "file_name": "20260721_162148_819725_Silicone_cube_deformable_10.npz",
  "sample_id": "S_A5E906BE3F7D4315A3A1FC0BB29854C0",
  "specimen_id": "Silicone_cube",
  "targets": {
    "deformation_response": "deformable",
    "stiffness": 10.0
  }
}

Data Format

Each .npz file must contain a key named frames.

frames.shape == (64, 32, 32)
frames.dtype == float32

The frame values are base-corrected tactile responses. The expected value range is [0, 1], where 0 represents no positive response after base correction.

The frame axis is ordered as:

(time, height, width)

Visualizing the Tactile Sequence

Each sample is a tactile time sequence, not a single image and not a 64-channel static tensor. The tensor should be interpreted as:

frames[t, y, x]

where:

Axis	Size	Meaning
`t`	64	Temporal frame index, ordered from the beginning to the end of one contact event.
`y`	32	Sensor row index.
`x`	32	Sensor column index.

Therefore, frames[0] is the first 32 × 32 tactile response map, frames[1] is the next response map, and frames[63] is the final response map in the sequence. A typical visualization treats each frames[t] as a 2D heatmap and plays the 64 maps in temporal order.

Display one frame

import numpy as np
import matplotlib.pyplot as plt

npz_path = "data/train/example.npz"

with np.load(npz_path, allow_pickle=False) as data:
    frames = data["frames"]

# frames.shape should be (64, 32, 32)
t = 0

plt.figure(figsize=(4, 4))
plt.imshow(frames[t], vmin=0.0, vmax=1.0, origin="lower")
plt.title(f"Tactile response frame {t}")
plt.xlabel("x taxel")
plt.ylabel("y taxel")
plt.colorbar(label="base-corrected response")
plt.tight_layout()
plt.show()

Play the 64-frame sequence

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation

npz_path = "data/train/example.npz"

with np.load(npz_path, allow_pickle=False) as data:
    frames = data["frames"]

fig, ax = plt.subplots(figsize=(4, 4))
im = ax.imshow(frames[0], vmin=0.0, vmax=1.0, origin="lower")
ax.set_xlabel("x taxel")
ax.set_ylabel("y taxel")
cbar = fig.colorbar(im, ax=ax)
cbar.set_label("base-corrected response")

def update(t):
    im.set_data(frames[t])
    ax.set_title(f"Tactile response frame {t}/63")
    return (im,)

ani = FuncAnimation(fig, update, frames=frames.shape[0], interval=80, blit=True)
plt.show()

Plot a simple temporal response curve

A quick way to inspect whether a sample contains a contact event is to sum the response over the 32 × 32 sensor grid for each time step:

import numpy as np
import matplotlib.pyplot as plt

npz_path = "data/train/example.npz"

with np.load(npz_path, allow_pickle=False) as data:
    frames = data["frames"]

contact_strength = frames.sum(axis=(1, 2))

plt.figure(figsize=(6, 3))
plt.plot(contact_strength)
plt.xlabel("frame index")
plt.ylabel("sum of tactile response")
plt.title("Temporal contact response")
plt.tight_layout()
plt.show()

This curve is only a diagnostic visualization. It reduces each 32 × 32 frame to one scalar and therefore does not preserve the full spatial contact pattern. For model training and detailed analysis, the complete (64, 32, 32) sequence should be used.

Metadata Fields

`file_name`

The actual .npz filename corresponding to the sample. This field must match the saved data filename exactly, including the .npz extension.

`sample_id`

A stable sample identifier. It is not used for file naming. Multiple captures from the same physical target may share or update this field depending on the acquisition protocol. In the current acquisition workflow, sample_id is automatically generated and changed manually when a new target or sample group is used.

`specimen_id`

A material or specimen identifier. It describes the physical object or material used in the sample. If the material or specimen is uncertain, this field should be null.

Examples:

"specimen_id": "Silicone_cube"

"specimen_id": null

`targets.deformation_response`

The binary deformation response label.

Allowed values:

Value	Meaning
`rigid`	The observed tactile response is treated as rigid or hard.
`deformable`	The observed tactile response is treated as deformable.

`targets.stiffness`

An optional numeric stiffness annotation. This value is not a calibrated physical standard and should not be interpreted as a universally comparable stiffness measurement. It is a human-estimated or experiment-level reference value, and may depend on the material, specimen, acquisition condition, or annotation convention.

Allowed values:

finite numeric value or null

Examples:

"stiffness": 10.0

"stiffness": null

If stiffness is null, the stiffness value is unknown, unavailable, or not assigned.

Splits

Split	Description
`train`	Samples used for model training.
`validation`	Samples used for validation and model selection.
`test`	Held-out samples used for final evaluation.

The split definition is stored in metadata/train.jsonl, metadata/validation.jsonl, and metadata/test.jsonl.

Loading the Dataset Metadata

from datasets import load_dataset

repo_id = "Tachintech/tactile-deformation-response"
dataset = load_dataset(repo_id)

print(dataset)
print(dataset["train"][0])

Loading a Tactile Sequence

import numpy as np
from datasets import load_dataset
from huggingface_hub import hf_hub_download

repo_id = "Tachintech/tactile-deformation-response"
dataset = load_dataset(repo_id)

row = dataset["train"][0]
npz_path = hf_hub_download(
    repo_id=repo_id,
    repo_type="dataset",
    filename=row["npz_path"],
)

with np.load(npz_path, allow_pickle=False) as data:
    frames = data["frames"]

print(frames.shape)  # (64, 32, 32)
print(frames.dtype)  # float32
print(row["deformation_response"], row["stiffness"])

Dataset Creation and Preprocessing

The tactile frames are collected from a 32 × 32 tactile array. Raw sensor values are normalized once at acquisition time and then corrected by a base value estimated from calibration data.

The saved frame tensor is expected to represent:

response = clip(normalized_raw - base_value, 0, 1)

The dataset does not include raw unnormalized uint16 sensor values unless explicitly provided in a separate field or file.

Recommended Validation Rules

Before uploading or training, each sample should satisfy:

npz contains key: frames
frames.shape == (64, 32, 32)
frames.dtype == float32
json.file_name == npz filename
targets.deformation_response in {"rigid", "deformable"}
targets.stiffness is finite numeric value or null

Intended Use

This dataset is intended for:

tactile time-series classification;
rigid versus deformable response modeling;
tactile representation learning;
sequence-model benchmarking for electronic-skin data;
analysis of contact response patterns across materials and specimens.

Out-of-Scope Use

This dataset should not be treated as:

a calibrated physical stiffness dataset;
a universal material-property benchmark;
a force-calibrated measurement dataset;
a dataset that directly transfers across all tactile sensors without adaptation.

Limitations

The data are tied to the sensor, acquisition procedure, normalization method, base correction, and annotation protocol used during collection. The stiffness value is not a strict physical ground-truth modulus or calibrated stiffness measurement. It should be interpreted as an auxiliary annotation rather than a standardized physical label.

The specimen_id field describes the material or object identity when known. If specimen_id is null, the material or specimen identity is uncertain.

Citation

If you use this dataset, cite the dataset repository. A formal citation can be added here after the dataset is published.

@dataset{tactile_deformation_response_dataset,
  title = {Tactile Deformation Response Dataset},
  author = {Tachintech},
  year = {2026},
  publisher = {Hugging Face},
  url = {https://huggingface.co/datasets/Tachintech/tactile-deformation-response}
}

License

license: gpl-3.0