README.md

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

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

```text
20260721_162148_819725_Silicone_cube_deformable_10.npz
20260721_162148_819725_Silicone_cube_deformable_10.json
```

The JSON metadata should contain:

```json
{
  "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`.

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

```text
(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:

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

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

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

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

```json
"specimen_id": "Silicone_cube"
```

```json
"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:

```text
finite numeric value or null
```

Examples:

```json
"stiffness": 10.0
```

```json
"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

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

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

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

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

```bibtex
@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