Duplicate from FactoryBench/FactoryBench

Co-authored-by: FactoryBench <FactoryBench@users.noreply.huggingface.co>

.gitattributes

@@ -0,0 +1,80 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.avro filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text
+factorybench_qa/level_1/train.jsonl filter=lfs diff=lfs merge=lfs -text
+factorybench_qa/level_1/validation.jsonl filter=lfs diff=lfs merge=lfs -text
+factorybench_qa/level_1/test.jsonl filter=lfs diff=lfs merge=lfs -text
+factorybench_qa/level_2/train.jsonl filter=lfs diff=lfs merge=lfs -text
+factorybench_qa/level_2/validation.jsonl filter=lfs diff=lfs merge=lfs -text
+factorybench_qa/level_2/test.jsonl filter=lfs diff=lfs merge=lfs -text
+factorybench_qa/level_3/train.jsonl filter=lfs diff=lfs merge=lfs -text
+factorybench_qa/level_3/test.jsonl filter=lfs diff=lfs merge=lfs -text
+factorybench_qa/level_4/train.jsonl filter=lfs diff=lfs merge=lfs -text
+factorybench_qa/level_4/validation.jsonl filter=lfs diff=lfs merge=lfs -text
+factorybench_qa/level_4/test.jsonl filter=lfs diff=lfs merge=lfs -text
+factorybench_lite/level_2/train.jsonl filter=lfs diff=lfs merge=lfs -text
+factorybench_lite/level_3/train.jsonl filter=lfs diff=lfs merge=lfs -text
+factorybench_qa/level_1.jsonl filter=lfs diff=lfs merge=lfs -text
+factorybench_qa/level_2.jsonl filter=lfs diff=lfs merge=lfs -text
+factorybench_qa/level_3.jsonl filter=lfs diff=lfs merge=lfs -text
+factorybench_qa/level_4.jsonl filter=lfs diff=lfs merge=lfs -text
+factorybench_lite/level_2.jsonl filter=lfs diff=lfs merge=lfs -text
+factorybench_lite/level_3.jsonl filter=lfs diff=lfs merge=lfs -text
+factorybench_lite/level_4.jsonl filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,225 @@
+---
+license: cc-by-4.0
+language:
+  - en
+task_categories:
+  - question-answering
+  - time-series-forecasting
+tags:
+  - robotics
+  - industrial
+  - time-series
+  - causal-reasoning
+  - benchmark
+  - machine-understanding
+pretty_name: FactoryBench
+size_categories:
+  - 10K<n<100K
+configs:
+  - config_name: level_1
+    data_files:
+      - split: train
+        path: factorybench_qa/level_1.jsonl
+  - config_name: level_2
+    data_files:
+      - split: train
+        path: factorybench_qa/level_2.jsonl
+  - config_name: level_3
+    data_files:
+      - split: train
+        path: factorybench_qa/level_3.jsonl
+  - config_name: level_4
+    data_files:
+      - split: train
+        path: factorybench_qa/level_4.jsonl
+  - config_name: lite_level_1
+    data_files:
+      - split: train
+        path: factorybench_lite/level_1.jsonl
+  - config_name: lite_level_2
+    data_files:
+      - split: train
+        path: factorybench_lite/level_2.jsonl
+  - config_name: lite_level_3
+    data_files:
+      - split: train
+        path: factorybench_lite/level_3.jsonl
+  - config_name: lite_level_4
+    data_files:
+      - split: train
+        path: factorybench_lite/level_4.jsonl
+---
+
+# FactoryBench
+
+FactoryBench is a benchmark for evaluating **machine-behavior reasoning** in time-series models and LLMs over industrial robotic telemetry. Question-answer pairs are organised along the four levels of Pearl's causal hierarchy:
+
+| Level | Capability | Example |
+|-------|-----------|---------|
+| **L1 — State** | Identify the operational state from raw signals | "Which fault, if any, is occurring in this episode?" |
+| **L2 — Intervention** | Predict the effect of an intervention | "How would the joint torques change if the payload were doubled?" |
+| **L3 — Counterfactual** | Reason about alternative histories | "Would the collision still have occurred if the speed had been 50% lower?" |
+| **L4 — Decision** | Engineering decision-making (troubleshooting + optimisation) | "Given this anomaly, what is the most likely root cause and remediation?" |
+
+The benchmark is grounded in **FactoryWave**, a dense multivariate telemetry dataset collected from a UR3 collaborative robot (125 Hz) and a KUKA KR10 industrial arm (83 Hz), supplemented with the AURSAD and voraus-AD open-source datasets.
+
+## Dataset summary
+
+- **69,691 Q&A pairs** across four causal levels, released as a single undivided pool (the public release is not split into train/validation/test).
+- **FactoryBench-Lite**: a balanced 3,000-item subset for cheap evaluation, even across templates and within each template on the dimension that determines its answer.
+- **5 answer formats**: single-select MCQ, multi-select MCQ, ranking, tensor/numerical, free-form (judged by an LLM-as-judge voting protocol).
+- **Telemetry from real industrial robots** with systematic fault injection (27 atomic mechanisms across pick-and-place, screwing, and peg-in-hole tasks).
+
+## Repository layout
+
+```
+FactoryBench/
+├── factorybench_qa/                 # Question-answer pairs (full pool)
+│   ├── level_1.jsonl
+│   ├── level_2.jsonl
+│   ├── level_3.jsonl
+│   └── level_4.jsonl
+├── factorybench_lite/               # Balanced 3,000-item evaluation subset
+│   ├── level_1.jsonl
+│   ├── level_2.jsonl
+│   ├── level_3.jsonl
+│   └── level_4.jsonl
+├── knowledge_graph/                 # Combined knowledge graph
+│   ├── knowledge_graph.json         # Machines, grippers, tasks, events, faults, anomalies, error→protocol map, relevance specs
+│   └── SCHEMA.md                    # Field-level schema documentation
+└── factorywave/                     # Underlying telemetry & metadata
+    ├── episodes.parquet             # Episode-level metadata (9,728 episodes)
+    ├── flow.parquet                 # Task flow definitions
+    ├── kuka_signals.parquet         # KUKA KR10 signals (~83 Hz, 1,428 episodes)
+    ├── ur_signals.parquet           # UR3 signals (~125 Hz, 3,076 episodes)
+    ├── ur_signals_10hz.parquet      # UR3 signals (10 Hz, 3,984 episodes — disjoint from ur_signals)
+    └── ur_screwdriver_signals.parquet  # UR3 screwdriver subset (~125 Hz, 1,240 episodes)
+```
+
+> **Note on UR coverage.** `ur_signals.parquet` (~125 Hz) and `ur_signals_10hz.parquet` (10 Hz) cover **disjoint** UR3 episode subsets — no episode appears in both files. Together they span 7,060 distinct UR3 episodes; `ur_screwdriver_signals.parquet` adds another 1,240 screwdriver-task episodes. Each row in `episodes.parquet` corresponds to exactly one signal table.
+
+## Knowledge graph
+
+`knowledge_graph/knowledge_graph.json` is the structured "world model" that grounds FactoryBench Q&A items: machine and gripper capability tables, the task/event vocabulary, the fault root-cause catalogue, the observable-anomaly catalogue, the error→protocol mapping used to derive ground-truth answers for L4 troubleshooting items, an anomaly severity ranking, and the relevance specs that drive fault-aware sub-series sampling. See [`knowledge_graph/SCHEMA.md`](https://huggingface.co/datasets/FactoryBench/FactoryBench/blob/main/knowledge_graph/SCHEMA.md) for field-level documentation.
+
+```python
+import json, urllib.request
+url = "https://huggingface.co/datasets/FactoryBench/FactoryBench/resolve/main/knowledge_graph/knowledge_graph.json"
+kg = json.loads(urllib.request.urlopen(url).read())
+
+# Machine spec lookup
+machines_by_id = {m["machine_id"]: m for m in kg["machines"]}
+
+# Error → operator protocol (the ground truth for L4 troubleshooting answers)
+protocol_for = {e["root_cause"]: e["ur3_protocol"] for e in kg["root_cause_error_mapping"]}
+print(protocol_for["collision_rigid_object"])
+```
+
+## Q&A pair counts
+
+| Level | Full pool | Lite  |
+|-------|-----------|-------|
+| L1    | 15,321    | 572   |
+| L2    | 40,226    | 1,430 |
+| L3    | 2,939     | 712   |
+| L4    | 11,205    | 286   |
+| **Total** | **69,691** | **3,000** |
+
+The public release is a single undivided pool per level. The `train` split name
+in the config block is the Hugging Face default for a single-file config, not a
+semantic split. A private 15% slice is held back for contamination checks and is
+not counted here.
+
+## Q&A fields
+
+Each line in `factorybench_qa/level_*.jsonl` (and `factorybench_lite/level_*.jsonl`) is a single Q&A item:
+
+| Field | Description |
+|-------|-------------|
+| `id` | Unique item identifier |
+| `level` | Causal level (1–4) |
+| `template_id` | Question template the item was generated from |
+| `template_type` | Answer format (`single_choice`, `multi_choice`, `ranking`, `tensor`, `free_form`) |
+| `hides` | Channels/fields hidden from the model in this item |
+| `question` | Natural-language question |
+| `options` | Answer options (for MCQ/ranking templates) |
+| `answer` | Ground-truth answer |
+| `root_cause` | Underlying fault/cause (Level 4 only) |
+| `acceptance_bounds` | Tolerance for numerical answers |
+| `provenance` | Source episode(s) and channels used to derive the item |
+| `context` | Time-series and metadata context exposed to the model |
+
+## Loading the data
+
+```python
+from datasets import load_dataset
+
+# Load one level of the full pool
+ds = load_dataset("FactoryBench/FactoryBench", "level_1", split="train")
+
+# Load one level of the balanced Lite subset
+lite = load_dataset("FactoryBench/FactoryBench", "lite_level_1", split="train")
+
+# Or address a file directly
+ds = load_dataset(
+    "FactoryBench/FactoryBench",
+    data_files="factorybench_qa/level_1.jsonl",
+    split="train",
+)
+
+# Load underlying telemetry
+import pandas as pd
+root = "hf://datasets/FactoryBench/FactoryBench/factorywave"
+episodes = pd.read_parquet(f"{root}/episodes.parquet")
+ur_125 = pd.read_parquet(f"{root}/ur_signals.parquet")
+ur_10  = pd.read_parquet(f"{root}/ur_signals_10hz.parquet")  # different episodes
+kuka   = pd.read_parquet(f"{root}/kuka_signals.parquet")
+screw  = pd.read_parquet(f"{root}/ur_screwdriver_signals.parquet")
+
+# Load the combined knowledge graph (machines, faults, error→protocol, ...)
+import json, urllib.request
+kg = json.loads(urllib.request.urlopen(
+    "https://huggingface.co/datasets/FactoryBench/FactoryBench/resolve/main/knowledge_graph/knowledge_graph.json"
+).read())
+```
+
+## Citation
+
+If you use FactoryBench, please cite the dataset and the two upstream open-source datasets it incorporates (AURSAD and voraus-AD):
+
+```bibtex
+@misc{anonymous2026factorybench,
+  title  = {FactoryBench: Evaluating Industrial Machine Understanding},
+  author = {Anonymous},
+  year   = {2026},
+  note   = {Submission under double-blind review}
+}
+
+@article{leporowski2022aursad,
+  title   = {{AURSAD}: Universal Robot Screwdriving Anomaly Detection Dataset},
+  author  = {Leporowski, B{\l}a{\.z}ej and Tola, Daniella and Hansen, Christian and Iosifidis, Alexandros},
+  journal = {arXiv preprint arXiv:2202.03211},
+  year    = {2022}
+}
+
+@misc{brockmann2024vorausad,
+  title         = {voraus-{AD}: A New Dataset for Anomaly Detection in Robot Applications},
+  author        = {Brockmann, Jan Thie{\ss} and Rudolph, Marco and Rosenhahn, Bodo and Wandt, Bastian},
+  year          = {2024},
+  eprint        = {2311.04153},
+  archivePrefix = {arXiv},
+  primaryClass  = {cs.RO}
+}
+```
+
+## Intended use & limitations
+
+**Intended use.** Benchmark evaluation of LLMs and time-series models on structured industrial Q&A reasoning tasks (state, intervention, counterfactual, decision-making).
+
+**Limitations.** Domain-specific to factory and industrial robotic scenarios; may not generalise to open-domain Q&A. Faults are atomic and drawn from a closed catalogue of 27 physically injected mechanisms — different from compound or gradual real-world faults. The dataset shows a size imbalance between Levels 2 and 3.
+
+**Out-of-scope.** Not intended for deployment in safety-critical, medical, legal, or financial decision systems without further validation by domain experts.
+
+## License
+
+Released under the [Creative Commons Attribution 4.0 International (CC BY 4.0)](https://creativecommons.org/licenses/by/4.0/) license. You may share and adapt the dataset for any purpose, including commercial, with appropriate attribution to the FactoryBench authors. The accompanying generator source code, evaluation scripts, LLM-as-judge prompts, and tooling (linked from the paper) are released separately under the MIT License.

factorybench_lite/level_2.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6ef0ec3817a15df7b2a9927f046b3b01c8ed3935f653ee2eb98f0bebc70a4279
+size 29363133

factorybench_lite/level_3.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fe357ea54f46aaaaa1045877ac688b2437440eba80bc30404a819b079a0e530e
+size 20657794

factorybench_lite/level_4.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:67b67a17934dafdaf31169c99806ed912d7e01ea6d2de82e376ebb1b9f4ad724
+size 11346278

factorybench_qa/level_1.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:62a9fbacaf8f2ef82cc68145ca2c6b86a49327deb8f6d8fcd6c81efccee98c62
+size 223181135

factorybench_qa/level_2.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8b7e701d46b70bbc8104d7439b2a96758d8b40c35310db41137962fe7f4c29f0
+size 781123077

factorybench_qa/level_3.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7705c2bc697b7b4c49a66648e44bb27dc127e89c1f7f808899c2ece53a8876c8
+size 88425267

factorybench_qa/level_4.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a8eda3a9e7ca3b6ef8670aae79a39fff86fa1b71b8ddea273009a4aed65e0be7
+size 682822132

factorywave/episodes.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b2faacd23e06a8f04ad5f6a86a0a4a46ed0afa97acf84523334e969852c3d5e5
+size 590237

factorywave/flow.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:75ded683a0290f13f3d487ec4e2a6d71ba87429882af43f223bd6e5fd824d9f5
+size 39287

factorywave/kuka_signals.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7d370fe91145462efde857e0a4eefa7dff516e52d104b413771111f038a13066
+size 424166979

factorywave/ur_screwdriver_signals.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9938924ac8c3961a4782531bb15de80c1d31c1b87bce7c746986b6d0585d5544
+size 1027042166

factorywave/ur_signals.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:413e20e296a293e9d31c7c77e309a1b92459eb7ed3ec071381be25f35aa07ccd
+size 1704885150

factorywave/ur_signals_10hz.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8d8ed6ad69a2230c50ad88c19f06d81595e67db8ef2ed16030dbc19b6669da4a
+size 220910648

knowledge_graph/SCHEMA.md

@@ -0,0 +1,147 @@
+# FactoryBench Knowledge Graph — Schema
+
+`knowledge_graph.json` bundles the structured "world model" that grounds FactoryBench Q&A items: machine and gripper capabilities, the task/event vocabulary, the fault catalogue, and the operator-facing remediation protocols. The prompt builders and answer-derivation code consult these tables to (a) inject relevant context into prompts and (b) generate ground-truth answers for L4 troubleshooting items.
+
+The file is a single JSON object with a top-level `$schema_version` and a `description`, plus the ten sections below. Every section value is either a `list` of records or a `dict`.
+
+## machines (list)
+
+Robot arms used as test platforms. One entry per physical machine class.
+
+| Field | Type | Notes |
+|-------|------|-------|
+| `machine_id` | int | Stable id referenced by `datasets[*].machine_id`. |
+| `machine_model` | str | Vendor model code (e.g. `"UR3e"`). |
+| `manufacturer`, `series` | str | Vendor metadata. |
+| `machine_type` | str | E.g. `"collaborative robot"`. |
+| `weight_kg`, `payload_kg`, `degrees_of_freedom` | num | Physical specs. |
+| `joint_rotation` | list[num] | Per-joint rotation limits. |
+| `typical_applications` | list[str] | Free-text capability tags. |
+| `control_interfaces` | list[str] | E.g. `["UrScript", "PolyScope"]`. |
+| `joint_speed_limits`, `rated_current_per_joint` | list[num] | Per-joint maxima. |
+| `safety_modes`, `joint_modes`, `robot_modes`, `runtime_states` | list[obj] | Enum tables (id ↔ human-readable label). |
+| `used_in_paper_for` | list[str] | Datasets/tasks this machine appears in. |
+
+## grippers (list)
+
+End-effectors. One entry per gripper class.
+
+| Field | Type | Notes |
+|-------|------|-------|
+| `gripper_id` | int | Stable id referenced by `datasets[*].gripper_id`. |
+| `gripper_model`, `manufacturer`, `gripper_type`, `actuation` | str | Vendor metadata. |
+| `finger_count`, `weight_kg`, `payload_kg`, `payload_kg_form_fit` | num | Physical specs. |
+| `grip_force_range_N`, `torque_range_Nm`, `max_stroke_mm`, `opening_range_mm` | obj/list | Force/motion ranges. |
+
+## datasets (list)
+
+The four episode collections that make up FactoryWave. One entry per (machine, gripper, task) combination.
+
+| Field | Type | Notes |
+|-------|------|-------|
+| `dataset_id` | str | E.g. `"factorywave"`, `"aursad"`, `"vorausad"`. |
+| `name`, `description` | str | Human-facing label. |
+| `machine_id`, `gripper_id` | int | FK into `machines` / `grippers`. |
+| `task_id` | int | FK into `tasks`. |
+| `source` | str | URL or citation. |
+| `license` | str | |
+
+## tasks (list)
+
+Task-level vocabulary: each task is a sequence of named phases the robot moves through.
+
+| Field | Type | Notes |
+|-------|------|-------|
+| `id` | int | Stable id referenced by `datasets[*].task_id` and used in `relevance_specs`. |
+| `name`, `description` | str | E.g. `"pick_and_place"`. |
+| `phases` | list[obj] | Ordered phase descriptors (id, name, intent). Used by phase-gated relevance sampling. |
+
+## events (list)
+
+Atomic events that can occur during a task (e.g. collision triggers, gripper transitions, screwdriver phase changes).
+
+| Field | Type | Notes |
+|-------|------|-------|
+| `id` | int | Stable event id encoded in episode rows under `event`. |
+| `name`, `description` | str | |
+| `tasks` | list[int] | Tasks where this event can occur. |
+| `variables` | list[obj] | Per-event observable variables and their ranges. |
+
+## root_causes (list)
+
+Catalogue of injectable fault mechanisms. The "physics" side of a fault.
+
+| Field | Type | Notes |
+|-------|------|-------|
+| `fault_id` | int | Stable id used in episode-level `fault_label`. Also the FK from `root_cause_error_mapping`. |
+| `task` | str | Which task this fault applies to. |
+| `root_cause` | str | Snake-case identifier (e.g. `"collision_rigid_object"`). FK from `root_cause_error_mapping[*].root_cause`. |
+| `description` | str | Plain-language explanation. |
+| `severity_levels` | list[obj] | Mild / moderate / severe variants and their parameters. |
+| `injectable` | bool | Whether the fault was actively injected (vs. passively observed). |
+| `possible_anomalies` | list[str] | FK into `anomalies[*].anomaly_name`. |
+| `simulation_procedure` | str | How to reproduce the fault. |
+| `datasets` | list[str] | FK into `datasets[*].dataset_id`. |
+
+## anomalies (list)
+
+Catalogue of *observable* symptoms (the "phenomenology" side of a fault).
+
+| Field | Type | Notes |
+|-------|------|-------|
+| `anomaly_name` | str | Snake-case identifier (e.g. `"sudden_torque_spike"`). |
+| `description` | str | What the anomaly looks like in the data. |
+| `relevant_features_from_schema` | list[str] | Which channels (`feedback_speed_*`, `effort_target_torque_*`, etc.) the anomaly manifests on. |
+
+A single fault can manifest as multiple anomalies, and a single anomaly can be caused by multiple faults — the join is via `root_causes[*].possible_anomalies`.
+
+## root_cause_error_mapping (list)
+
+The error-to-protocol table. Maps each `fault_id` / `root_cause` to the UR3 controller error it raises (when any) and the operator-facing remediation protocol.
+
+| Field | Type | Notes |
+|-------|------|-------|
+| `fault_id` | int | FK into `root_causes`. |
+| `root_cause` | str | Mirror of `root_causes[*].root_cause` (denormalised for direct lookup). |
+| `ur3_error_code` | str / null | UR3 controller error code (e.g. `"C 39 A 1"`), `null` for software-only faults. |
+| `ur3_error_name` | str / null | Human-readable error name as shown on the teach pendant. |
+| `ur3_description` | str / null | What the controller reports to the operator. |
+| `ur3_protocol` | str | Step-by-step remediation procedure. **This is the ground-truth answer for L4 troubleshooting items.** |
+
+## anomaly_ranking (dict)
+
+Severity ordering of anomalies, used by the rubric scorer.
+
+| Field | Type | Notes |
+|-------|------|-------|
+| `ranking_least_to_most_severe` | list[str] | Anomaly names in ascending severity. |
+
+## relevance_specs (dict)
+
+Drives fault-aware sub-series sampling — i.e. picking a window where the fault's signature is observable rather than uniformly random. See `src/question_generation/utils/relevance.py`.
+
+| Field | Type | Notes |
+|-------|------|-------|
+| `version` | str | Spec version. |
+| `description` | str | Human-facing summary. |
+| `locality_definitions` | dict | The four sampling localities: `global` (uniform), `event` (window must contain transient), `phase_gated` (window must overlap target task phase), `cumulative` (length-based with optional phase gate). |
+| `defaults` | dict | Per-locality default parameters merged into each spec. |
+| `specs` | dict | Per-`fault_id` overrides. Keys are stringified fault ids; values declare locality, target phases, min window length, etc. |
+
+Set `FB_RELEVANCE=0` in the environment to bypass and fall back to uniform sampling.
+
+## Loading
+
+```python
+import json, urllib.request
+
+URL = "https://huggingface.co/datasets/FactoryBench/FactoryBench/resolve/main/knowledge_graph/knowledge_graph.json"
+kg = json.loads(urllib.request.urlopen(URL).read())
+
+# Machine spec lookup by id
+machines_by_id = {m["machine_id"]: m for m in kg["machines"]}
+
+# Error→protocol lookup
+protocol_for = {e["root_cause"]: e["ur3_protocol"] for e in kg["root_cause_error_mapping"]}
+print(protocol_for["collision_rigid_object"])
+```