Datasets:

ppak10
/

Inova-Mk1-Telemetry

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

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 PrintProfiles entities:

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

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