README.md

---
license: mit
tags:
- telemetry
- time-series
- sls
- 3d-printing
- additive-manufacturing
- inova-mk1
configs:
- config_name: ticks
  data_files:
  - split: train
    path: data/ticks/*.parquet
  default: true
dataset_info:
  features:
  - name: frame_chamber
    dtype: image
  - name: frame_galvo
    dtype: image
  - name: frame_thermal
    dtype: image
---

# Inova-Mk1-Telemetry

Time-aligned printer-state recordings from Inova Mk1 SLS print runs. One row per 10 Hz **tick** of the recorder's `/state/snapshot` poll, with the full sensor state (~64 columns: temperatures, position, power, lights) on every row, the nearest camera frame paths attached when one fell in the prior 100 ms window, and any 1 kHz position-stream samples from that window collected as a nested list.

Builds are denormalized into every row, so each parquet file is self-sufficient for ML — no joins needed for build context. The `print_profile_name` string the printer was running is preserved on every row; consumers who want the matching UUID from [`ppak10/Inova-Mk1-Database`](https://huggingface.co/datasets/ppak10/Inova-Mk1-Database) can resolve it themselves (one-liner shown below) — this dataset deliberately doesn't bake that join in, so it has no cross-dataset dependency at load time.

```python
from datasets import load_dataset
ticks = load_dataset("ppak10/Inova-Mk1-Telemetry", split="train")
row = ticks[0]
# row["frame_chamber"]   → PIL.Image.Image (or None)
# row["frame_thermal"]   → PIL.Image.Image (or None)
# row["powderBed.temp.current"] → float (°C)
# row["position_hf_burst"]      → list of {ts_offset_ms, x, y, z1, z2, r, has_homed}
```

The full image bytes ship inside each row — no separate frame download required. Filter to rows that have a particular frame kind with `ticks.filter(lambda r: r["frame_chamber"] is not None)`.

---

## Row shape

Each row is one moment in time (a single 10 Hz tick). 80+ columns:

| Group | Columns | Notes |
|---|---|---|
| **Build context** (denormalized) | `build_id`, `job_name`, `started_at`, `ended_at`, `phase`, `print_profile_name`, `inova_session_id` | Same value on every row in a given parquet file. `inova_session_id` is null until the upstream `build_to_inova_session.csv` is filled in by hand. |
| **Tick timestamp** | `ts` (`timestamp[us, UTC]`) | The `respondedAt` field on the `/state/snapshot` frame. |
| **Position (10 Hz)** | `positions.position.{x,y,z1,z2,r}` | Stage position at the tick, **microns** (firmware native; e.g. `z1 = 47272.79` is 47.27 mm). Always present. |
| **Lights** | `lights.lights.{enabled,count}` | |
| **Power (W)** | `{laser,fanGalvo,buzzer,laserSafety,io-en,wd-en,wd-in}.power`, `powerman.power.{current,required,max}` | Per-component power draw and the overall manager state. |
| **Temperature (°C)** | `{powderBed,printBed}.temp.{current,average,target}`, `{powderChamber1..4,printChamber1..4}.temp.{current,average,target}`, `{quadrant1..4,surface,surfaceAvg,surfaceMin,surfaceMax,testTemp1}.temp.{current,average}` | ~51 columns. All firmware temperatures in °C. |
| **Frame images** | `frame_chamber`, `frame_galvo`, `frame_thermal` | Embedded image bytes per HF `Image` feature (struct of `{bytes, path}`). Null when no frame of that kind was captured in the 100 ms window before the tick. Loads as a `PIL.Image` via `datasets`. The `path` field inside the struct preserves the original filename for traceability. |
| **Position burst** | `position_hf_burst` | A `list<struct<ts_offset_ms, x, y, z1, z2, r, has_homed>>`. Captures any 1 kHz position-stream events that fell in `(tick_ts - 100 ms, tick_ts]`. Empty list when no motion was happening. |

## Files

```
data/ticks/{build_id:03d}.parquet      # one file per build that had telemetry, zero-padded to 3 digits

previews/{build_id:03d}/                # per-build MP4 previews (real-time, 10 fps)
  chamber.mp4                          # optical
  thermal.mp4                          # IR matrix
  galvo.mp4                            # scan-mirror trace
  composite.mp4                        # 1×3 panel: chamber | thermal | galvo
```

12 builds had recorded telemetry; very-short failed-heating builds (~12–38 s, no rows) produce no parquet. The HF glob `data/ticks/*.parquet` loads everything across builds. Previews are derived from the same parquet files — every build that has a parquet also has previews.

## What's lost vs the raw exporter format

This dataset is **tick-anchored**, not strict-outer-join. Compared to the upstream flat exports, three things are reduced:

- **Position resolution between motion bursts**: the 1 kHz `position_hf` stream is preserved *during* motion (via the per-tick `position_hf_burst` list) but not as standalone rows between ticks. If you need the raw 1 kHz timeline outside the 100 ms windows, fall back to the upstream `position_hf/{build_id}.parquet`.
- **Sparse-stream events without telemetry**: there is no row for a frame timestamp that doesn't fall near a 10 Hz tick, and no row for sparse `events` (build phase transitions, etc.). Treat this dataset as "what was the state at each tick", not "every recorded event".
- **`plotter_commands`**: not exposed yet — historical builds predate the recorder feature, and the table is empty.

## Joining back to Inova-Mk1-Database

Each row carries `print_profile_name` — the string the printer was running when the build started, taken straight from the `build_start` event payload. To recover the matching `PrintProfile.Id` UUID, join against the [`ppak10/Inova-Mk1-Database`](https://huggingface.co/datasets/ppak10/Inova-Mk1-Database) `PrintProfiles` entities:

```python
import json
from pathlib import Path

# Wherever you've cloned/snapshotted Inova-Mk1-Database
profiles_dir = Path("Inova-Mk1-Database/source/PrintProfiles")
name_to_id = {
    json.load(p.open())["Name"]: json.load(p.open())["Id"]
    for p in profiles_dir.glob("*.json")
}

ticks = ticks.map(lambda r: {**r, "print_profile_id": name_to_id.get(r["print_profile_name"])})
```

If `Inova-Mk1-Database` hasn't yet added the profile the build used, the lookup returns null and `print_profile_name` is still preserved as a breadcrumb.

A planned authoritative `inova_session_id UUID` will replace the name-based fallback once the upstream `Agentic-Additive-Manufacturing-Process-Optimization/data/exports/build_to_inova_session.csv` has been filled in.

## Upstream

The raw data lives in the sibling repository [`Agentic-Additive-Manufacturing-Process-Optimization`](https://github.com/ppak10/Agentic-Additive-Manufacturing-Process-Optimization). Its `scripts/export.py` writes flat files under `data/exports/`. This dataset reads from there directly via a sibling-folder relative path — no live database connection required.

## Previews

Each build that has a parquet also has four MP4s under `previews/{build_id:03d}/`: separate `chamber.mp4` / `thermal.mp4` / `galvo.mp4` and a `composite.mp4` showing all three side-by-side. They play back at 10 fps — the tick rate — so each video's duration equals the build's wall-clock duration (build 26 → ~9h54m of video). Null frames are forward-filled so the picture keeps moving through long heating stretches.

Previews are sourced from this dataset's own parquet (not the recorder's raw frames), so they see only the per-tick-attached frame subset (~36% chamber, ~37% galvo, ~16% thermal of ticks). The result is choppier than playing the recorder's raw frames at native rate, but the previews are fully self-contained.

## Regenerate

```sh
uv run scripts/ticks/01_extract.py            # all builds with telemetry
uv run scripts/ticks/01_extract.py 13 26      # specific build ids

uv run scripts/previews/01_render.py          # all builds with parquet
uv run scripts/previews/01_render.py 13 26    # specific build ids
```