Add verified Raspberry Pi 5 edge performance measurements

Record actual 16 GB Pi 5 latency, RAM and correctness with frozen evaluation inputs, raw per-call measurements, runtime hashes and reproducible settings. Preserve weights and existing training data.

.gitattributes

@@ -1,3 +1,4 @@
 *.safetensors filter=lfs diff=lfs merge=lfs -text
 *.gz filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
+edge_benchmarks/rpi5-2026-09-26/temperature_latency.png filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,255 +1,270 @@
----
-license: apache-2.0
-library_name: transformers
-pipeline_tag: text-generation
-language:
-- en
-- hi
-tags:
-- text-to-json
-- home-automation
-- tiny-model
-- from-scratch
-- experimental
-- edge-ai
-datasets:
-- sraivante/home-commands-json-v1
----
-
-# Superfast Tiny Home Robotics JSON 1M v1
-
-A **1,094,240-parameter model trained from scratch** to turn short English and
-Romanized Hindi/Hinglish home commands into `activity`, `subject`, `action` JSON.
-It has **3 decoder layers** and **4.38 MB of FP32 weights**. It is an 
-text-to-command parser for use as small local models and edge inference.
-
-**Observed limitation:** it has no reject/no-op class and can turn
-`Do not turn on the fan` into an `ON` command. The examples below only return data; they execute no
-device actions. Native-script Hindi is not supported by the reported results.
-
-| Release | Value |
-| --- | --- |
-| Author / publisher | sraivante |
-| Release date | 2026-09-25 |
-| Version | `v1.0.2` |
-| Related dataset | [home-commands-json-v1](https://huggingface.co/datasets/sraivante/home-commands-json-v1/tree/v1.0.2) |
-| Architecture | Llama-style causal decoder, randomly initialized; no pretrained base weights |
-| Output space | 30 commands: 10 device types × ON / OFF / STATUS |
-
-## Edge-device use and measured speed
-
-The small weights make this an edge-inference research candidate. **The timings
-below were measured on an Intel CPU, not on a Raspberry Pi.** ARM latency, power,
-thermal throttling and end-to-end robot performance remain unmeasured.
-
-Host: **Intel Core i7-1360P**, Windows 11, Python 3.13.14, CPU PyTorch 2.12.0,
-Transformers 4.56.2. Batch size 1, FP32, 20 warmups and 200 timed requests per
-run. Timing includes tokenization and constrained JSON generation, and excludes
-HTTP, speech recognition, sensors, ROS and actuation.
-
-| CPU threads | Median latency | p95 latency | p99 latency | Serial throughput |
-| --- | ---: | ---: | ---: | ---: |
-| 1 | **17.35 ms/command** | **22.31 ms** | 28.46 ms | 55.30 commands/s |
-| 4 | 19.80 ms/command | 24.70 ms | 26.90 ms | 49.72 commands/s |
-
-Weights occupy **4,380,048 bytes (4.38 MB / 4.18 MiB)**. The complete desktop
-Python/PyTorch process used approximately **440 MiB resident RAM**, with roughly
-442 MiB peak working set; this includes substantial runtime overhead. Weight
-size is not total deployment RAM. Libraries took 6.79 seconds to import;
-weight loading after import took 0.013 seconds with filesystem caches potentially
-warm. No core pinning or power-mode control was used.
-
-Reproduce on 64-bit Raspberry Pi/ARM Linux from a downloaded repository:
-
-```bash
-python -m pip install -r requirements.txt psutil
-python assessment/benchmark_device.py --model . --threads 1 --repeats 2000 --out pi-1thread.json
-python assessment/benchmark_device.py --model . --threads 4 --repeats 2000 --out pi-4threads.json
-```
-
-Run these sequentially, then compare p95/p99, memory and sustained thermal
-behavior on the actual target. This release has no validated quantized or
-compiled edge-runtime export. [Full desktop benchmark records](assessment/robotics_edge_v1/desktop_cpu_1thread.json)
-and [detailed assessment](assessment/robotics_edge_v1/REPORT.md) are included.
-
-## Quick start: JSON command output
-
-Install PyTorch for your platform and the tested Transformers/tokenizer versions:
-
-```bash
-pip install "torch>=2.6,<3" "transformers==4.56.2" "tokenizers==0.22.1" "huggingface_hub>=0.35,<2"
-```
-
-Download the versioned repository and use the included inference helper:
-
-```python
-import sys
-from huggingface_hub import snapshot_download
-
-folder = snapshot_download("sraivante/superfast-tiny-home-robotics-json-1m-v1", revision="v1.0.2")
-sys.path.insert(0, folder)
-from tiny_json_llm.infer import JsonCommandModel
-
-model = JsonCommandModel(folder, device="cpu")
-print(model.predict("Please turn on the fan"))
-# {'action': 'ON', 'activity': 'air', 'subject': 'fan'}
-
-print(model.predict("pankha band karo"))
-# {'action': 'OFF', 'activity': 'air', 'subject': 'fan'}
-
-print(model.predict("check the water pump status"))
-# {'action': 'STATUS', 'activity': 'water', 'subject': 'motor'}
-```
-
-The helper uses a token trie of the 30 training-observed JSON commands. This
-ensures membership in the command set, **not semantic correctness or permission
-to actuate**. Empty/overlong input raises `ValueError`; unsupported short input
-can still return an unrelated command.
-
-Command-line use after downloading the repository:
-
-```bash
-python -m tiny_json_llm.infer --model . --device cpu --input "turn on the light"
-```
-
-## Standard Transformers usage: unconstrained generation
-
-The release includes a chat template that exactly reproduces the training
-framing for **one user message**. It deliberately rejects conversation history
-and system prompts, which were not trained as supported tasks.
-
-```python
-import torch
-from transformers import AutoModelForCausalLM, AutoTokenizer
-
-repo = "sraivante/superfast-tiny-home-robotics-json-1m-v1"
-tokenizer = AutoTokenizer.from_pretrained(repo, revision="v1.0.2")
-model = AutoModelForCausalLM.from_pretrained(repo, revision="v1.0.2").eval()
-inputs = tokenizer.apply_chat_template(
-    [{"role": "user", "content": "Please turn on the fan"}],
-    add_generation_prompt=True, return_tensors="pt", return_dict=True,
-)
-with torch.inference_mode():
-    result = model.generate(
-        **inputs, max_new_tokens=32, do_sample=False,
-        pad_token_id=tokenizer.pad_token_id,
-        eos_token_id=tokenizer.eos_token_id,
-    )
-print(tokenizer.decode(result[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True))
-```
-
-This second example is raw generation; JSON validity is not constrained. The
-context is 128 tokens including framing and output. Keep input short and
-validate both generated JSON and its intended meaning before downstream use.
-
-## Output schema and scope
-
-```json
-{"action":"ON","activity":"air","subject":"fan"}
-```
-
-Actions: `ON`, `OFF`, `STATUS`.
-
-| Subject | Activity |
-| --- | --- |
-| fan | air |
-| light | light |
-| motor | water |
-| speaker | music |
-| geyser | heating |
-| cooler | cooling |
-| washing_machine | laundry |
-| tv | entertainment |
-| ac | cooling |
-| sprinkler | garden |
-
-`motor` means the dataset's **water-pump motor**, not an arbitrary robot motor.
-The schema has no speed, position, distance, duration, device instance, room,
-conditional execution, multi-action or reject field. No chat, reasoning,
-native-script Hindi, perception, motion planning or robotic-control capability
-is claimed.
-
-## Evaluation
-
-All results below use the same weights identified in `weights_sha256.json`.
-The original test data is templated and overlaps the training distribution.
-The later stress test was frozen before inference and is a small manually
-authored diagnostic, not a representative sample or safety certification.
-
-| Evaluation | Correct / total | Exact JSON accuracy |
-| --- | ---: | ---: |
-| Original held-out test, constrained generation | 104,723 / 104,723 | 100% |
-| Original stratified raw-generation diagnostic | 1,816 / 1,816 | 100% |
-| Later supported-command challenges | 68 / 140 | 48.6% |
-| Challenges with no source-phrase overlap | 48 / 120 | 40.0% |
-| New paraphrase wording | 14 / 30 | 46.7% |
-| Hinglish variations | 8 / 30 | 26.7% |
-| Typos / ASR-style text perturbations | 6 / 30 | 20.0% |
-| Contrastive negation | 10 / 20 | 50.0% |
-
-The later supported-command accuracies were identical with constrained and raw
-generation; both produced valid JSON for all 140 supported-command challenges.
-Native-script Hindi passed 0/10 diagnostic cases. Four empty/overlong input
-guards passed. Neither decoding mode produced an explicit reject/no-op response
-on 130 requests requiring abstention. Constrained mode emitted a known command
-for all 130, including **33 ON/OFF commands**.
-
-Concrete failures:
-
-- `Do not turn on the fan.` → fan `ON`.
-- `Turn the fan on, not off.` → fan `OFF`.
-- `thank you` → water-pump motor `ON`.
-
-The 284 challenge cases, all 568 predictions across both modes, overlap audit,
-metrics and reproducible evaluation scripts are included. The challenge data
-is also versioned in the linked dataset's `robotics_edge_v1` configuration.
-If these cases guide future training, reserve fresh tests for the next release.
-
-## Training and reproducibility
-
-Source: user-supplied `home-commands-3.4M.jsonl`, 3,458,816 rows. Normalized-input
-deduplication removed 2,340,890 rows, leaving 1,117,926 examples. Phrase-family
-grouping reduced case/punctuation/politeness leakage; other paraphrase overlap
-can remain. The split is stratified by command class across 2,868 phrase families.
-
-| Split | Examples | Phrase families |
-| --- | ---: | ---: |
-| Train | 910,114 | 2,292 |
-| Validation | 103,089 | 288 |
-| Test | 104,723 | 288 |
-
-Tokenizer: training-only byte-level BPE, vocabulary 1,024. Architecture: hidden
-width 160, intermediate width 432, 5 attention heads of dimension 32, 3 layers,
-RoPE, RMSNorm, SwiGLU, tied embeddings/output, context 128.
-
-Training completed on NVIDIA A100-SXM4-80GB: one epoch, 1,778 updates and
-22,655,302 nonpadding prediction tokens. Objective: full-sequence causal
-next-token loss. AdamW LR 0.001, betas (0.9, 0.95), weight decay 0.1, 5% warmup,
-cosine decay to 10% of peak LR, gradient clipping 1, microbatch 128, effective
-batch 512, BF16 computation and FP32 weights/optimizer. Seed: 20260925.
-Validation response NLL on a fixed 4,096-example subset selected the best model;
-best and final exports are identical at step 1,778.
-
-The 20.70 training-tokens/parameter ratio is a **Chinchilla-inspired sizing
-heuristic**, not evidence of compute optimality. This small, highly templated
-corpus is outside the original experiments' scale and diversity.
-
-The linked dataset includes the exact source, prepared train/validation/test
-JSONL, tokenizer/memmap training bundle and the manifest used in training.
-See `training/` for source code, run summary and logs, and `release_manifest.json`
-for source, model, package and artifact hashes. No extra fine-tuning occurred.
-
-## License, provenance and attribution
-
-Apache License 2.0 for this original release material; see [LICENSE](https://huggingface.co/sraivante/superfast-tiny-home-robotics-json-1m-v1/blob/v1.0.2/LICENSE)
-and [NOTICE](https://huggingface.co/sraivante/superfast-tiny-home-robotics-json-1m-v1/blob/v1.0.2/NOTICE). **Copyright (c) 2026 sraivante** applies to original user
-contributions and original selection/arrangement. Third-party ownership and
-license terms remain unchanged. The source was supplied by the publisher; its
-upstream generation process and historical source revision were not provided
-or independently verified. The source SHA identifies the exact received file.
-No external corpus or pretrained base weights were added in this run.
-
-Packaging adds a one-user chat template and corrects tokenizer context metadata
-to 128; token IDs, vocabulary and learned weights are unchanged. The historical
-assessment and training manifest are preserved. Their pre-publication packaging
-notes are superseded by this release's cards, license and authorization record.
+---
+license: apache-2.0
+library_name: transformers
+pipeline_tag: text-generation
+language:
+- en
+- hi
+tags:
+- text-to-json
+- home-automation
+- tiny-model
+- from-scratch
+- experimental
+- edge-ai
+datasets:
+- sraivante/home-commands-json-v1
+---
+
+# Superfast Tiny Home Robotics JSON 1M v1
+
+A **1,094,240-parameter model trained from scratch** to turn short English and
+Romanized Hindi/Hinglish home commands into `activity`, `subject`, `action` JSON.
+It has **3 decoder layers** and **4.38 MB of FP32 weights**. It is an 
+text-to-command parser for use as small local models and edge inference.
+
+**Observed limitation:** it has no reject/no-op class and can turn
+`Do not turn on the fan` into an `ON` command. The examples below only return data; they execute no
+device actions. Native-script Hindi is not supported by the reported results.
+
+| Release | Value |
+| --- | --- |
+| Author / publisher | sraivante |
+| Release date | 2026-09-25 |
+| Version | `v1.0.2` |
+| Related dataset | [home-commands-json-v1](https://huggingface.co/datasets/sraivante/home-commands-json-v1/tree/v1.0.2) |
+| Architecture | Llama-style causal decoder, randomly initialized; no pretrained base weights |
+| Output space | 30 commands: 10 device types × ON / OFF / STATUS |
+
+<!-- rpi5-measurements -->
+## Raspberry Pi 5 edge-device performance
+
+Measured **2026-09-26** on a **Raspberry Pi 5 Model B, 16 GB RAM**, Debian 13.2/aarch64, Python 3.13.5. Measurement update: `edge-rpi5-20260926`; weights and training data are unchanged.
+
+| Threads | Median ms | p95 ms | p99 ms | Serial requests/s | Process RSS MiB | CPU °C min–mean–max | Timed correct |
+| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
+| 1 | 87.95 | 99.85 | 100.80 | 11.20 | 398.83 | 55.1–57.1–59.5 | 500/500 |
+| 4 | 96.34 | 111.38 | 128.25 | 10.05 | 399.16 | 60.0–65.6–68.3 | 500/500 |
+
+Batch 1; 20 warmups and 500 timed calls per row, cycling over 10 frozen model-specific inputs. **Each timed reading has a matching CPU-temperature sample**, captured immediately afterward outside the latency timer; the table shows min–mean–max temperature. RSS includes Python/runtime overhead. Timings include local text-to-output inference and exclude loading, SSH/HTTP, speech recognition and actuation. Throughput is serial reciprocal mean. Runs used one and four CPU/BLAS threads sequentially. These synthetic workloads do not establish cross-model superiority or robot-control reliability.
+
+On-device quality check: **72/284** on existing frozen stress/regression suite, constrained decoding only. See the report for per-category results and previously observed limitations.
+
+[Full Pi methodology, temperature plot and reproduction](edge_benchmarks/rpi5-2026-09-26/REPORT.md) · [Every latency/temperature reading](edge_benchmarks/rpi5-2026-09-26/readings.csv) · [Raw measurements](edge_benchmarks/rpi5-2026-09-26/results) · [Versioned evaluation data](https://huggingface.co/datasets/sraivante/home-commands-json-v1/tree/edge-rpi5-20260926/edge_benchmarks/rpi5-2026-09-26).
+<!-- /rpi5-measurements -->
+
+## Edge-device use and measured speed
+
+The small weights make this an edge-inference research candidate. The new Raspberry Pi measurements are recorded above. The following table preserves the earlier Intel desktop results. Power, sustained thermal behavior and end-to-end robot performance remain unmeasured.
+
+Host: **Intel Core i7-1360P**, Windows 11, Python 3.13.14, CPU PyTorch 2.12.0,
+Transformers 4.56.2. Batch size 1, FP32, 20 warmups and 200 timed requests per
+run. Timing includes tokenization and constrained JSON generation, and excludes
+HTTP, speech recognition, sensors, ROS and actuation.
+
+| CPU threads | Median latency | p95 latency | p99 latency | Serial throughput |
+| --- | ---: | ---: | ---: | ---: |
+| 1 | **17.35 ms/command** | **22.31 ms** | 28.46 ms | 55.30 commands/s |
+| 4 | 19.80 ms/command | 24.70 ms | 26.90 ms | 49.72 commands/s |
+
+Weights occupy **4,380,048 bytes (4.38 MB / 4.18 MiB)**. The complete desktop
+Python/PyTorch process used approximately **440 MiB resident RAM**, with roughly
+442 MiB peak working set; this includes substantial runtime overhead. Weight
+size is not total deployment RAM. Libraries took 6.79 seconds to import;
+weight loading after import took 0.013 seconds with filesystem caches potentially
+warm. No core pinning or power-mode control was used.
+
+Reproduce on 64-bit Raspberry Pi/ARM Linux from a downloaded repository:
+
+```bash
+python -m pip install -r requirements.txt psutil
+python assessment/benchmark_device.py --model . --threads 1 --repeats 2000 --out pi-1thread.json
+python assessment/benchmark_device.py --model . --threads 4 --repeats 2000 --out pi-4threads.json
+```
+
+Run these sequentially, then compare p95/p99, memory and sustained thermal
+behavior on the actual target. This release has no validated quantized or
+compiled edge-runtime export. [Full desktop benchmark records](assessment/robotics_edge_v1/desktop_cpu_1thread.json)
+and [detailed assessment](assessment/robotics_edge_v1/REPORT.md) are included.
+
+## Quick start: JSON command output
+
+Install PyTorch for your platform and the tested Transformers/tokenizer versions:
+
+```bash
+pip install "torch>=2.6,<3" "transformers==4.56.2" "tokenizers==0.22.1" "huggingface_hub>=0.35,<2"
+```
+
+Download the versioned repository and use the included inference helper:
+
+```python
+import sys
+from huggingface_hub import snapshot_download
+
+folder = snapshot_download("sraivante/superfast-tiny-home-robotics-json-1m-v1", revision="v1.0.2")
+sys.path.insert(0, folder)
+from tiny_json_llm.infer import JsonCommandModel
+
+model = JsonCommandModel(folder, device="cpu")
+print(model.predict("Please turn on the fan"))
+# {'action': 'ON', 'activity': 'air', 'subject': 'fan'}
+
+print(model.predict("pankha band karo"))
+# {'action': 'OFF', 'activity': 'air', 'subject': 'fan'}
+
+print(model.predict("check the water pump status"))
+# {'action': 'STATUS', 'activity': 'water', 'subject': 'motor'}
+```
+
+The helper uses a token trie of the 30 training-observed JSON commands. This
+ensures membership in the command set, **not semantic correctness or permission
+to actuate**. Empty/overlong input raises `ValueError`; unsupported short input
+can still return an unrelated command.
+
+Command-line use after downloading the repository:
+
+```bash
+python -m tiny_json_llm.infer --model . --device cpu --input "turn on the light"
+```
+
+## Standard Transformers usage: unconstrained generation
+
+The release includes a chat template that exactly reproduces the training
+framing for **one user message**. It deliberately rejects conversation history
+and system prompts, which were not trained as supported tasks.
+
+```python
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+repo = "sraivante/superfast-tiny-home-robotics-json-1m-v1"
+tokenizer = AutoTokenizer.from_pretrained(repo, revision="v1.0.2")
+model = AutoModelForCausalLM.from_pretrained(repo, revision="v1.0.2").eval()
+inputs = tokenizer.apply_chat_template(
+    [{"role": "user", "content": "Please turn on the fan"}],
+    add_generation_prompt=True, return_tensors="pt", return_dict=True,
+)
+with torch.inference_mode():
+    result = model.generate(
+        **inputs, max_new_tokens=32, do_sample=False,
+        pad_token_id=tokenizer.pad_token_id,
+        eos_token_id=tokenizer.eos_token_id,
+    )
+print(tokenizer.decode(result[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True))
+```
+
+This second example is raw generation; JSON validity is not constrained. The
+context is 128 tokens including framing and output. Keep input short and
+validate both generated JSON and its intended meaning before downstream use.
+
+## Output schema and scope
+
+```json
+{"action":"ON","activity":"air","subject":"fan"}
+```
+
+Actions: `ON`, `OFF`, `STATUS`.
+
+| Subject | Activity |
+| --- | --- |
+| fan | air |
+| light | light |
+| motor | water |
+| speaker | music |
+| geyser | heating |
+| cooler | cooling |
+| washing_machine | laundry |
+| tv | entertainment |
+| ac | cooling |
+| sprinkler | garden |
+
+`motor` means the dataset's **water-pump motor**, not an arbitrary robot motor.
+The schema has no speed, position, distance, duration, device instance, room,
+conditional execution, multi-action or reject field. No chat, reasoning,
+native-script Hindi, perception, motion planning or robotic-control capability
+is claimed.
+
+## Evaluation
+
+All results below use the same weights identified in `weights_sha256.json`.
+The original test data is templated and overlaps the training distribution.
+The later stress test was frozen before inference and is a small manually
+authored diagnostic, not a representative sample or safety certification.
+
+| Evaluation | Correct / total | Exact JSON accuracy |
+| --- | ---: | ---: |
+| Original held-out test, constrained generation | 104,723 / 104,723 | 100% |
+| Original stratified raw-generation diagnostic | 1,816 / 1,816 | 100% |
+| Later supported-command challenges | 68 / 140 | 48.6% |
+| Challenges with no source-phrase overlap | 48 / 120 | 40.0% |
+| New paraphrase wording | 14 / 30 | 46.7% |
+| Hinglish variations | 8 / 30 | 26.7% |
+| Typos / ASR-style text perturbations | 6 / 30 | 20.0% |
+| Contrastive negation | 10 / 20 | 50.0% |
+
+The later supported-command accuracies were identical with constrained and raw
+generation; both produced valid JSON for all 140 supported-command challenges.
+Native-script Hindi passed 0/10 diagnostic cases. Four empty/overlong input
+guards passed. Neither decoding mode produced an explicit reject/no-op response
+on 130 requests requiring abstention. Constrained mode emitted a known command
+for all 130, including **33 ON/OFF commands**.
+
+Concrete failures:
+
+- `Do not turn on the fan.` → fan `ON`.
+- `Turn the fan on, not off.` → fan `OFF`.
+- `thank you` → water-pump motor `ON`.
+
+The 284 challenge cases, all 568 predictions across both modes, overlap audit,
+metrics and reproducible evaluation scripts are included. The challenge data
+is also versioned in the linked dataset's `robotics_edge_v1` configuration.
+If these cases guide future training, reserve fresh tests for the next release.
+
+## Training and reproducibility
+
+Source: user-supplied `home-commands-3.4M.jsonl`, 3,458,816 rows. Normalized-input
+deduplication removed 2,340,890 rows, leaving 1,117,926 examples. Phrase-family
+grouping reduced case/punctuation/politeness leakage; other paraphrase overlap
+can remain. The split is stratified by command class across 2,868 phrase families.
+
+| Split | Examples | Phrase families |
+| --- | ---: | ---: |
+| Train | 910,114 | 2,292 |
+| Validation | 103,089 | 288 |
+| Test | 104,723 | 288 |
+
+Tokenizer: training-only byte-level BPE, vocabulary 1,024. Architecture: hidden
+width 160, intermediate width 432, 5 attention heads of dimension 32, 3 layers,
+RoPE, RMSNorm, SwiGLU, tied embeddings/output, context 128.
+
+Training completed on NVIDIA A100-SXM4-80GB: one epoch, 1,778 updates and
+22,655,302 nonpadding prediction tokens. Objective: full-sequence causal
+next-token loss. AdamW LR 0.001, betas (0.9, 0.95), weight decay 0.1, 5% warmup,
+cosine decay to 10% of peak LR, gradient clipping 1, microbatch 128, effective
+batch 512, BF16 computation and FP32 weights/optimizer. Seed: 20260925.
+Validation response NLL on a fixed 4,096-example subset selected the best model;
+best and final exports are identical at step 1,778.
+
+The 20.70 training-tokens/parameter ratio is a **Chinchilla-inspired sizing
+heuristic**, not evidence of compute optimality. This small, highly templated
+corpus is outside the original experiments' scale and diversity.
+
+The linked dataset includes the exact source, prepared train/validation/test
+JSONL, tokenizer/memmap training bundle and the manifest used in training.
+See `training/` for source code, run summary and logs, and `release_manifest.json`
+for source, model, package and artifact hashes. No extra fine-tuning occurred.
+
+## License, provenance and attribution
+
+Apache License 2.0 for this original release material; see [LICENSE](https://huggingface.co/sraivante/superfast-tiny-home-robotics-json-1m-v1/blob/v1.0.2/LICENSE)
+and [NOTICE](https://huggingface.co/sraivante/superfast-tiny-home-robotics-json-1m-v1/blob/v1.0.2/NOTICE). **Copyright (c) 2026 sraivante** applies to original user
+contributions and original selection/arrangement. Third-party ownership and
+license terms remain unchanged. The source was supplied by the publisher; its
+upstream generation process and historical source revision were not provided
+or independently verified. The source SHA identifies the exact received file.
+No external corpus or pretrained base weights were added in this run.
+
+Packaging adds a one-user chat template and corrects tokenizer context metadata
+to 128; token IDs, vocabulary and learned weights are unchanged. The historical
+assessment and training manifest are preserved. Their pre-publication packaging
+notes are superseded by this release's cards, license and authorization record.

edge_benchmarks/rpi5-2026-09-26/REPORT.md

@@ -0,0 +1,74 @@
+# Raspberry Pi 5 measurements — Tiny Home Robotics JSON 1M v1
+
+Measured on 2026-09-26; measurement revision `edge-rpi5-20260926`. The model weights and training data were not changed.
+
+Hardware: **Raspberry Pi 5 Model B Rev 1.1**, 15.84 GiB OS-visible RAM (16 GB model), four CPU cores, aarch64, Debian 13.2, kernel `6.12.47+rpt-rpi-2712`. Python 3.13.5. The device's governor and library versions are recorded in each JSON result. Cooling and power-supply model were not inspected.
+
+## Measured performance
+
+| Threads | Median ms | p95 ms | p99 ms | Serial requests/s | Process RSS MiB | CPU °C min–mean–max | Timed correct |
+| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
+| 1 | 87.95 | 99.85 | 100.80 | 11.20 | 398.83 | 55.1–57.1–59.5 | 500/500 |
+| 4 | 96.34 | 111.38 | 128.25 | 10.05 | 399.16 | 60.0–65.6–68.3 | 500/500 |
+
+Each row is a separate sequential process: batch 1, 20 warmups, 500 timed requests cycling over 10 frozen synthetic inputs. Timing covers the adapter's complete local text-to-output call; it excludes model loading, SSH/network transfer, HTTP/UI, speech recognition, and actuation. RSS includes Python and runtime overhead. Peak RSS is Linux VmHWM sampled after the timed loop and includes imports/initialization. Serial requests/s is 1000 divided by mean latency; it is not concurrent-serving throughput. These model-specific input sets do not establish a controlled cross-model speed ranking.
+
+Runtime: FP32 PyTorch; greedy generation constrained to the 30 training-observed JSON commands.
+
+Thread counts set PyTorch/BLAS intra-op limits; PyTorch inter-op is one. No CPU affinity or power mode was changed. Actual loaded thread-pool metadata is in the raw results.
+
+The benchmark runs left existing host services running. CPU temperature is read immediately after **every timed inference**, outside the latency timer, with per-call UTC timestamps. Sensor reads add a small gap between requests. The table reports the minimum, mean and maximum of those 500 matched temperature readings per row. The sensor types are recorded in each JSON. Thread configurations ran one then four without a controlled cooldown; temperatures depend on run order and background load. Start/end snapshots ranged from 54.5 to 67.2 °C; observed firmware flags: `throttled=0x0`. This short run is not a power or long-duration stability measurement.
+
+![Latency and CPU temperature for each reading](temperature_latency.png)
+
+[Download all matched latency/temperature readings](readings.csv). Mean latency, import/load times and peak RSS are in the raw result JSON.
+
+## Command correctness on this device
+
+| Diagnostic group | Correct / cases |
+| --- | ---: |
+| supported/literal_control | 30/30 |
+| supported/paraphrase | 14/30 |
+| supported/hinglish | 8/30 |
+| supported/typos_and_asr_style | 6/30 |
+| supported/contrastive_negation | 10/20 |
+| unclaimed_language/native_hindi_diagnostic | 0/10 |
+| reject/prohibition | 0/20 |
+| reject/quoted_or_hypothetical | 0/10 |
+| reject/delayed_or_conditional | 0/10 |
+| reject/unsupported_device | 0/20 |
+| reject/robotics_or_unrepresentable_parameter | 0/20 |
+| reject/ambiguous_or_multi_step | 0/20 |
+| reject/out_of_domain | 0/20 |
+| reject/noise_or_instruction_injection | 0/10 |
+| guard/input_guard | 4/4 |
+
+existing frozen stress/regression suite, constrained decoding only. Previously inspected synthetic suite; not a new blind holdout. Original per-case source-overlap metadata retained.
+
+Timed-correct counts above describe the repeated ten-input latency set, not an independent accuracy estimate. Recorded inference errors: 0 across the timed runs. No model retraining, output correction, host action or device actuation was performed.
+
+## Artifact and dataset identity
+
+- Published model tested: [`sraivante/superfast-tiny-home-robotics-json-1m-v1@cf325b380e8ed560a729ec2de09f878a8a917259`](https://huggingface.co/sraivante/superfast-tiny-home-robotics-json-1m-v1/tree/cf325b380e8ed560a729ec2de09f878a8a917259). All tested runtime assets were checked against this revision.
+- Learned weight SHA-256: `7eed2ed8eb5455f4195cba48ff38b2bc8ff8228cefaf7ee6c477200c776a8ea3` (4,380,048 bytes).
+- Associated preserved training dataset: [`sraivante/home-commands-json-v1@8479d12161767c5aabd7dfc097e6f6c41790201a`](https://huggingface.co/datasets/sraivante/home-commands-json-v1/tree/8479d12161767c5aabd7dfc097e6f6c41790201a). Existing source/split hashes and historical provenance remain in that snapshot. No fine-tuning was performed for this measurement update.
+- The [versioned evaluation inputs and Pi predictions](https://huggingface.co/datasets/sraivante/home-commands-json-v1/tree/edge-rpi5-20260926/edge_benchmarks/rpi5-2026-09-26) record the new diagnostic snapshot. `provenance.json` records its hashes, counts, source revisions, and historical identity limitations.
+- [Runtime identity check](runtime_identity.json); [raw per-call records](results); [exact environment](environment.lock.txt).
+
+## Reproduce
+
+Use a 64-bit Raspberry Pi in an isolated environment. Download this model repository at `edge-rpi5-20260926`, then run:
+
+```bash
+python3 -m venv .venv
+. .venv/bin/activate
+python -m pip install -r edge_benchmarks/rpi5-2026-09-26/environment.lock.txt
+python edge_benchmarks/rpi5-2026-09-26/reproduce.py --threads 1
+python edge_benchmarks/rpi5-2026-09-26/reproduce.py --threads 4
+```
+
+The helper downloads the pinned runtime files above, checks SHA-256, stages the exact case files, and invokes the included `benchmark.py`. It refuses to report a non-Pi host as a Pi result. Downloading requires network access; timed inference runs offline. The original run's full bundle hash differs from the per-model reproduction manifest; the original hash is retained inside each result.
+
+## License and limitations
+
+Copyright (c) 2026 sraivante for original benchmark code, evaluation material and selection/arrangement, under Apache License 2.0. Third-party ownership and licenses remain unchanged. Synthetic/regression diagnostics do not establish real-user or robot-control reliability. Existing model-specific limitations still apply; latency is not a safety or end-to-end performance guarantee.

edge_benchmarks/rpi5-2026-09-26/benchmark.py

@@ -0,0 +1,268 @@
+"""Batch-one inference benchmark for five frozen workspace projects.
+
+No executor, host adapter, server, MQTT, or GPIO code is imported or called.
+Copyright (c) 2026 sraivante. Licensed under Apache License 2.0.
+"""
+from __future__ import annotations
+
+import argparse
+from collections import defaultdict
+from datetime import datetime, timezone
+import hashlib
+import importlib.metadata
+import json
+import os
+from pathlib import Path
+import platform
+import statistics
+import subprocess
+import sys
+import time
+
+HERE = Path(__file__).resolve().parent
+
+
+def digest(path):
+    with Path(path).open("rb") as stream:
+        return hashlib.file_digest(stream, "sha256").hexdigest()
+
+
+def read_text(path):
+    try:
+        return Path(path).read_text().strip("\x00\n")
+    except OSError:
+        return None
+
+
+def host_state():
+    import psutil
+    throttled = None
+    try:
+        throttled = subprocess.check_output(["vcgencmd", "get_throttled"], text=True, timeout=5).strip()
+    except (OSError, subprocess.SubprocessError):
+        pass
+    return {
+        "load_average": list(os.getloadavg()) if hasattr(os, "getloadavg") else None,
+        "available_ram_bytes": psutil.virtual_memory().available,
+        "temperature_c": {p.parent.name: float(p.read_text()) / 1000
+                          for p in Path("/sys/class/thermal").glob("thermal_zone*/temp")},
+        "cpu_frequency_khz": {p.parent.parent.name: int(p.read_text())
+                              for p in Path("/sys/devices/system/cpu").glob("cpu*/cpufreq/scaling_cur_freq")},
+        "throttled": throttled,
+    }
+
+
+def hardware():
+    import psutil
+    return {"raspberry_pi_model": read_text("/proc/device-tree/model"),
+            "system": platform.system(), "kernel": platform.release(),
+            "architecture": platform.machine(), "os_release": read_text("/etc/os-release"),
+            "logical_cpus": psutil.cpu_count(), "physical_cpus": psutil.cpu_count(logical=False),
+            "ram_bytes": psutil.virtual_memory().total,
+            "temperature_sensor_types": {p.parent.name: p.read_text().strip()
+                                         for p in Path("/sys/class/thermal").glob("thermal_zone*/type")},
+            "governors": {p.parent.parent.name: p.read_text().strip()
+                          for p in Path("/sys/devices/system/cpu").glob("cpu*/cpufreq/scaling_governor")}}
+
+
+def memory():
+    import psutil
+    info = psutil.Process().memory_info()._asdict()
+    status = read_text("/proc/self/status") or ""
+    for line in status.splitlines():
+        if line.startswith("VmHWM:"):
+            info["peak_rss"] = int(line.split()[1]) * 1024
+    return info
+
+
+def temperature():
+    return {p.parent.name: float(p.read_text()) / 1000
+            for p in Path("/sys/class/thermal").glob("thermal_zone*/temp")}
+
+
+def summary(values):
+    ordered = sorted(values)
+    def quantile(q):
+        rank = (len(ordered) - 1) * q
+        lo = int(rank)
+        hi = min(lo + 1, len(ordered) - 1)
+        return ordered[lo] + (ordered[hi] - ordered[lo]) * (rank - lo)
+    return {"n": len(values), "mean": statistics.mean(values), "p50": quantile(.5),
+            "p95": quantile(.95), "p99": quantile(.99), "min": min(values), "max": max(values)}
+
+
+def load_adapter(key, root, threads):
+    start = time.perf_counter()
+    if key == "poc1":
+        sys.path.insert(0, str(root))
+        import torch
+        from tiny_json_llm.infer import JsonCommandModel
+        torch.set_num_threads(threads)
+        torch.set_num_interop_threads(1)
+        imports = time.perf_counter() - start
+        start = time.perf_counter()
+        model = JsonCommandModel(root / "best_model", device="cpu")
+        predict = lambda row: model.predict(row["text"])
+        params = sum(p.numel() for p in model.model.parameters())
+        mode = "FP32 PyTorch; greedy generation constrained to the 30 training-observed JSON commands"
+    elif key == "poc2":
+        sys.path.insert(0, str(root))
+        import engine
+        imports = time.perf_counter() - start
+        start = time.perf_counter()
+        engine.init(str(root / "model"))
+        predict = lambda row: json.loads(engine.parse_scored(row["text"])[0])
+        params = sum(p.size for p in engine._W.values())
+        mode = "FP16 NPZ storage expanded to FP32 NumPy; KV-cached greedy character generation, max_new=170; JSON parsing included, catalog validation excluded"
+    elif key == "poc3":
+        sys.path.insert(0, str(root))
+        from edge_command import Interpreter
+        imports = time.perf_counter() - start
+        start = time.perf_counter()
+        model = Interpreter(str(root))
+        predict = lambda row: model.parse(row["text"])
+        params = None
+        mode = "Standard-library action classifier with rules and read-only SQLite catalog; not an autoregressive LLM"
+    elif key == "agent_claude":
+        sys.path.insert(0, str(root / "model"))
+        from runtime import CommandModel
+        imports = time.perf_counter() - start
+        start = time.perf_counter()
+        model = CommandModel(str(root / "artifacts/final"))
+        def predict(row):
+            value = model.predict(row["text"])
+            return {k: v for k, v in value.items() if k != "_meta"}
+        params = sum(p.size for p in model.W.values())
+        mode = "NumPy encoder/decoder transformer with grammar constraints; FP32 runtime; includes normalization and JSON conversion"
+    elif key == "agent_codex":
+        sys.path.insert(0, str(root / "app"))
+        from inference import local_model, predict as infer
+        imports = time.perf_counter() - start
+        start = time.perf_counter()
+        local_model()
+        predict = lambda row: infer(row["text"], platform=row.get("platform", "pi"), engine="local")
+        params = None
+        mode = "scikit-learn intent classifier with policy and argument parsing; not an autoregressive LLM; no host execution"
+    else:
+        raise ValueError(key)
+    return predict, params, mode, imports, time.perf_counter() - start
+
+
+def outcome(row, value, error):
+    if row.get("match") == "rejection":
+        return bool(error or (isinstance(value, dict) and ("error" in value or value.get("action") in {"unknown", "REJECT", "NOOP", "CLARIFY", "ABSTAIN"})))
+    if error:
+        return False
+    if row.get("match") == "subset":
+        return isinstance(value, dict) and all(value.get(k) == v for k, v in row["expected"].items())
+    return value == row["expected"]
+
+
+def call(predict, row):
+    started = time.perf_counter_ns()
+    try:
+        value, error = predict(row), None
+    except (ValueError, KeyError, IndexError) as exc:
+        value, error = None, f"{type(exc).__name__}: {exc}"
+    elapsed = (time.perf_counter_ns() - started) / 1e6
+    return value, error, elapsed
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--model", required=True)
+    parser.add_argument("--threads", type=int, default=1, choices=(1, 4))
+    parser.add_argument("--repeats", type=int, default=500)
+    parser.add_argument("--warmup", type=int, default=20)
+    parser.add_argument("--quality", action="store_true")
+    parser.add_argument("--allow-nonpi", action="store_true", help="Development checks only, recorded as non-Pi")
+    parser.add_argument("--out", type=Path, required=True)
+    args = parser.parse_args()
+    assert args.repeats >= 20 and args.warmup >= 0
+    for name in ("OMP_NUM_THREADS", "OPENBLAS_NUM_THREADS", "MKL_NUM_THREADS", "BLIS_NUM_THREADS", "VECLIB_MAXIMUM_THREADS", "NUMEXPR_NUM_THREADS"):
+        os.environ[name] = str(args.threads)
+    os.environ["TOKENIZERS_PARALLELISM"] = "false"
+    os.environ["HF_HUB_OFFLINE"] = "1"
+    host = hardware()
+    is_pi = bool(host["raspberry_pi_model"] and "Raspberry Pi" in host["raspberry_pi_model"])
+    assert is_pi or args.allow_nonpi, "This run must execute on real Raspberry Pi hardware"
+    manifest = json.loads((HERE / "bundle_manifest.json").read_text())
+    spec = manifest["models"][args.model]
+    # Verify the full runtime and evaluation input before importing any model code.
+    for rel, entry in spec["files"].items():
+        assert digest(HERE / rel) == entry["sha256"], f"Frozen input differs: {rel}"
+    latency_cases = json.loads((HERE / "cases" / f"{args.model}_latency.json").read_text())
+    before = host_state()
+    memory_before = memory()
+    predict, params, mode, import_s, load_s = load_adapter(args.model, HERE / "projects" / args.model, args.threads)
+    memory_loaded = memory()
+    for i in range(args.warmup):
+        call(predict, latency_cases[i % len(latency_cases)])
+    samples = []
+    for i in range(args.repeats):
+        row = latency_cases[i % len(latency_cases)]
+        started_utc = datetime.now(timezone.utc).isoformat()
+        value, error, elapsed = call(predict, row)
+        samples.append({"case_id": row["id"], "elapsed_ms": elapsed,
+                        "started_utc": started_utc, "temperature_c": temperature(),
+                        "temperature_sampled_utc": datetime.now(timezone.utc).isoformat(),
+                        "correct": outcome(row, value, error), "output": value, "error": error})
+        if (i + 1) % 100 == 0:
+            print(f"{args.model} threads={args.threads}: latency {i + 1}/{args.repeats}", flush=True)
+    memory_after_latency, after_latency = memory(), host_state()
+    lat = summary([s["elapsed_ms"] for s in samples])
+    result = {"created_utc": datetime.now(timezone.utc).isoformat(), "model": args.model,
+              "is_raspberry_pi": is_pi, "hardware": host, "environment_before": before,
+              "environment_after_latency": after_latency,
+              "bundle_manifest_sha256": digest(HERE / "bundle_manifest.json"),
+              "benchmark_script_sha256": digest(Path(__file__)), "model_spec": spec,
+              "settings": {"threads_requested": args.threads, "batch_size": 1,
+                           "warmup_requests": args.warmup, "timed_requests": args.repeats,
+                           "unique_latency_cases": len(latency_cases), "mode": mode,
+                           "cpu_pinning": False, "power_mode_changed": False},
+              "parameters": params, "import_seconds": import_s, "load_seconds_after_import": load_s,
+              "latency_ms": lat, "serial_requests_per_second": 1000 / lat["mean"],
+              "timed_correct": sum(s["correct"] for s in samples),
+              "timed_errors": sum(s["error"] is not None for s in samples),
+              "memory_bytes": {"before_runtime_import": memory_before, "after_model_load": memory_loaded,
+                               "after_latency": memory_after_latency},
+              "latency_samples": samples,
+              "temperature_measurement": "Linux thermal-zone CPU temperature read immediately after every timed inference, outside the latency timer; start and temperature-read UTC timestamps are retained per call. Sensor reads add a small gap between requests. These samples do not establish power consumption or a long-duration thermal limit.",
+              "measurement_scope": "Warm local Python process, full text-to-structured-output call through the specified adapter, serial batch one. Timing excludes SSH, HTTP/UI, model loading, speech recognition, actuation and per-call correctness checks. Small repeated synthetic input set with warm OS/model caches; throughput is reciprocal mean, not concurrent serving. Other host services were left running. No power meter or sustained thermal test; cooling and power-supply model were not inspected."}
+    result["software"] = {"python": platform.python_version(), "sqlite": __import__("sqlite3").sqlite_version}
+    for package in ("torch", "transformers", "tokenizers", "safetensors", "numpy", "scipy", "scikit-learn", "joblib", "threadpoolctl", "psutil"):
+        try:
+            result["software"][package] = importlib.metadata.version(package)
+        except importlib.metadata.PackageNotFoundError:
+            pass
+    try:
+        from threadpoolctl import threadpool_info
+        result["thread_pools"] = [{k: v for k, v in p.items() if k != "filepath"} for p in threadpool_info()]
+    except ImportError:
+        result["thread_pools"] = []
+    if args.quality:
+        rows = json.loads((HERE / "cases" / f"{args.model}_quality.json").read_text())
+        predictions, groups = [], defaultdict(list)
+        for i, row in enumerate(rows):
+            value, error, elapsed = call(predict, row)
+            ok = outcome(row, value, error)
+            predictions.append({**row, "output": value, "error": error, "correct": ok, "elapsed_ms": elapsed,
+                                "temperature_c": temperature(), "temperature_sampled_utc": datetime.now(timezone.utc).isoformat()})
+            groups[row["category"]].append(ok)
+            if (i + 1) % 100 == 0:
+                print(f"{args.model}: quality {i + 1}/{len(rows)}", flush=True)
+        result["quality"] = {"cases": len(rows), "correct": sum(p["correct"] for p in predictions),
+                             "by_category": {k: {"n": len(v), "correct": sum(v)} for k, v in groups.items()},
+                             "provenance": spec["quality_provenance"], "predictions": predictions}
+        result["environment_after_quality"] = host_state()
+    args.out.parent.mkdir(parents=True, exist_ok=True)
+    temporary = args.out.with_suffix(".partial.json")
+    temporary.write_text(json.dumps(result, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    temporary.replace(args.out)
+    print(json.dumps({"model": args.model, "threads": args.threads, "latency_ms": lat,
+                      "rss_mib": memory_after_latency["rss"] / 1024**2,
+                      "timed_correct": result["timed_correct"], "result": str(args.out)}), flush=True)
+
+
+if __name__ == "__main__":
+    main()

edge_benchmarks/rpi5-2026-09-26/bundle_manifest.json

@@ -0,0 +1,479 @@
+{
+  "models": {
+    "poc1": {
+      "workspace_project": "POC-1",
+      "weight_sha256": "7eed2ed8eb5455f4195cba48ff38b2bc8ff8228cefaf7ee6c477200c776a8ea3",
+      "weight_bytes": 4380048,
+      "files": {
+        "projects/poc1/tiny_json_llm/data.py": {
+          "bytes": 18760,
+          "sha256": "b1c6dd1207327bc8b9a325391d60762d419589b900ad1329ed21a13df48bc66b",
+          "workspace_source": "POC-1/publication/model/tiny_json_llm/data.py"
+        },
+        "projects/poc1/tiny_json_llm/evaluate.py": {
+          "bytes": 6317,
+          "sha256": "1efd2f862da1fdc6fb17006547de7c53321dbd29aa16c4097daccbfb8dc41e4d",
+          "workspace_source": "POC-1/publication/model/tiny_json_llm/evaluate.py"
+        },
+        "projects/poc1/tiny_json_llm/infer.py": {
+          "bytes": 4260,
+          "sha256": "2b5074bce3f07127fa254c4ec62e25c6b8ce58743b937cdd301d7bb05128a5c8",
+          "workspace_source": "POC-1/publication/model/tiny_json_llm/infer.py"
+        },
+        "projects/poc1/tiny_json_llm/train.py": {
+          "bytes": 17277,
+          "sha256": "911848ac7816a1a58bbad171a75e1e5e74a9e2790f18492e69d41e0ec4c8ed2a",
+          "workspace_source": "POC-1/publication/model/tiny_json_llm/train.py"
+        },
+        "projects/poc1/tiny_json_llm/__init__.py": {
+          "bytes": 103,
+          "sha256": "e8edab0c5d6fc4202a0b3005dfb4009894ed4c06f216c801943a88f88b7653c2",
+          "workspace_source": "POC-1/publication/model/tiny_json_llm/__init__.py"
+        },
+        "projects/poc1/best_model/allowed_outputs.json": {
+          "bytes": 2590,
+          "sha256": "317d35bd27a25e6db66deea50112633b63f7eae907178cc7f50f12dd8ad6aba1",
+          "workspace_source": "POC-1/publication/model/allowed_outputs.json"
+        },
+        "projects/poc1/best_model/config.json": {
+          "bytes": 682,
+          "sha256": "a66629f39ecb44414aefdf78aa947829e37daf6e6a44be8d710e944ec90ef60a",
+          "workspace_source": "POC-1/publication/model/config.json"
+        },
+        "projects/poc1/best_model/generation_config.json": {
+          "bytes": 132,
+          "sha256": "9b962893b09457be3f8b0d343c8d64d33048443e2e57fbe421cd40d2dec8edf9",
+          "workspace_source": "POC-1/publication/model/generation_config.json"
+        },
+        "projects/poc1/best_model/manifest.json": {
+          "bytes": 12618,
+          "sha256": "2ead74207a38ad593819da12c52392bad8a273cc62e6842a8278ebffaa561eaa",
+          "workspace_source": "POC-1/publication/model/manifest.json"
+        },
+        "projects/poc1/best_model/model.safetensors": {
+          "bytes": 4380048,
+          "sha256": "7eed2ed8eb5455f4195cba48ff38b2bc8ff8228cefaf7ee6c477200c776a8ea3",
+          "workspace_source": "POC-1/publication/model/model.safetensors"
+        },
+        "projects/poc1/best_model/output_schema.json": {
+          "bytes": 797,
+          "sha256": "e5c670db2756306cfb58f43e020426a174aef2f60c643ec0cc72920be4aaae86",
+          "workspace_source": "POC-1/publication/model/output_schema.json"
+        },
+        "projects/poc1/best_model/special_tokens_map.json": {
+          "bytes": 531,
+          "sha256": "eae55585dbdfe3c1875015bd0a96dee1b5103a5ab4ef97797de606fb385ea51d",
+          "workspace_source": "POC-1/publication/model/special_tokens_map.json"
+        },
+        "projects/poc1/best_model/tokenizer.json": {
+          "bytes": 54877,
+          "sha256": "0e2e4281172d6ff20e5562d8e0df4c796ca6c0a9e1804067e1b62bdefe38317e",
+          "workspace_source": "POC-1/publication/model/tokenizer.json"
+        },
+        "projects/poc1/best_model/tokenizer_config.json": {
+          "bytes": 2077,
+          "sha256": "66e9e99973752a3b3b6adf621fa1574aa576da1fd2f344b8673196de207da9ad",
+          "workspace_source": "POC-1/publication/model/tokenizer_config.json"
+        },
+        "projects/poc1/best_model/training_metadata.json": {
+          "bytes": 1190,
+          "sha256": "5fd7ee7df81d8699b853cfa2e33ee70b5ff8172ef8de67b11aee54e8cf73d11f",
+          "workspace_source": "POC-1/publication/model/training_metadata.json"
+        },
+        "projects/poc1/best_model/weights_sha256.json": {
+          "bytes": 94,
+          "sha256": "0d186660bf35658801dea63222e4de0612c237ba13553569535f5b5077824ba1",
+          "workspace_source": "POC-1/publication/model/weights_sha256.json"
+        },
+        "cases/poc1_quality.json": {
+          "bytes": 193903,
+          "sha256": "a3e20755d442252731b96f8faff4a9d5b4e4074af130f9b4c9063be5e60504ee"
+        },
+        "cases/poc1_latency.json": {
+          "bytes": 2180,
+          "sha256": "157cb10e338b20c09e7c383eb9d5ed1f23984ded1984f32f2d228b65ee8e6700"
+        }
+      },
+      "quality_provenance": {
+        "kind": "existing frozen stress/regression suite, constrained decoding only",
+        "source": "POC-1\\assessment\\robotics_edge_v1\\cases.jsonl",
+        "sha256": "30cb9a6de18cc12cefcbb6e1aac8a29c7371b0f4ea537e516f38d02b3f417d6c",
+        "notes": "Previously inspected synthetic suite; not a new blind holdout. Original per-case source-overlap metadata retained."
+      },
+      "hf": {
+        "model": "sraivante/superfast-tiny-home-robotics-json-1m-v1",
+        "dataset": "sraivante/home-commands-json-v1",
+        "local_weight": "POC-1/tiny_home_json_model_v1/best_model/model.safetensors",
+        "weight_name": "model.safetensors",
+        "repositories": {
+          "model": {
+            "repo_id": "sraivante/superfast-tiny-home-robotics-json-1m-v1",
+            "commit": "cf325b380e8ed560a729ec2de09f878a8a917259",
+            "files": [
+              {
+                "path": ".gitattributes",
+                "bytes": 133,
+                "sha256": null
+              },
+              {
+                "path": "LICENSE",
+                "bytes": 11357,
+                "sha256": null
+              },
+              {
+                "path": "NOTICE",
+                "bytes": 728,
+                "sha256": null
+              },
+              {
+                "path": "README.md",
+                "bytes": 11097,
+                "sha256": null
+              },
+              {
+                "path": "allowed_outputs.json",
+                "bytes": 2590,
+                "sha256": null
+              },
+              {
+                "path": "assessment/RASPBERRY_PI.md",
+                "bytes": 709,
+                "sha256": null
+              },
+              {
+                "path": "assessment/benchmark_device.py",
+                "bytes": 6302,
+                "sha256": null
+              },
+              {
+                "path": "assessment/build_challenge.py",
+                "bytes": 10121,
+                "sha256": null
+              },
+              {
+                "path": "assessment/evaluate_edge.py",
+                "bytes": 5579,
+                "sha256": null
+              },
+              {
+                "path": "assessment/robotics_edge_v1/REPORT.md",
+                "bytes": 10707,
+                "sha256": null
+              },
+              {
+                "path": "assessment/robotics_edge_v1/cases.jsonl",
+                "bytes": 95602,
+                "sha256": null
+              },
+              {
+                "path": "assessment/robotics_edge_v1/desktop_cpu_1thread.json",
+                "bytes": 8389,
+                "sha256": null
+              },
+              {
+                "path": "assessment/robotics_edge_v1/desktop_cpu_4threads.json",
+                "bytes": 8390,
+                "sha256": null
+              },
+              {
+                "path": "assessment/robotics_edge_v1/hf_compatibility.json",
+                "bytes": 457,
+                "sha256": null
+              },
+              {
+                "path": "assessment/robotics_edge_v1/manifest.json",
+                "bytes": 1694,
+                "sha256": null
+              },
+              {
+                "path": "assessment/robotics_edge_v1/metrics.json",
+                "bytes": 14385,
+                "sha256": null
+              },
+              {
+                "path": "assessment/robotics_edge_v1/predictions.jsonl",
+                "bytes": 389133,
+                "sha256": null
+              },
+              {
+                "path": "config.json",
+                "bytes": 682,
+                "sha256": null
+              },
+              {
+                "path": "evaluation/metrics.json",
+                "bytes": 10936,
+                "sha256": null
+              },
+              {
+                "path": "evaluation/raw_diagnostic_predictions.jsonl.gz",
+                "bytes": 16504,
+                "sha256": "dc834114aafc7c28982f8440e2493e59e24cbafa79476a3e00f0d048c33b803f"
+              },
+              {
+                "path": "evaluation/test_predictions.jsonl.gz",
+                "bytes": 498154,
+                "sha256": "cfd68ce95dd52db54461812a9c1e61679d693c117576e35b59728f4ef9e8fb01"
+              },
+              {
+                "path": "generation_config.json",
+                "bytes": 132,
+                "sha256": null
+              },
+              {
+                "path": "manifest.json",
+                "bytes": 12618,
+                "sha256": null
+              },
+              {
+                "path": "model.safetensors",
+                "bytes": 4380048,
+                "sha256": "7eed2ed8eb5455f4195cba48ff38b2bc8ff8228cefaf7ee6c477200c776a8ea3"
+              },
+              {
+                "path": "output_schema.json",
+                "bytes": 797,
+                "sha256": null
+              },
+              {
+                "path": "release_manifest.json",
+                "bytes": 9317,
+                "sha256": null
+              },
+              {
+                "path": "requirements.txt",
+                "bytes": 111,
+                "sha256": null
+              },
+              {
+                "path": "special_tokens_map.json",
+                "bytes": 531,
+                "sha256": null
+              },
+              {
+                "path": "tiny_json_llm/__init__.py",
+                "bytes": 103,
+                "sha256": null
+              },
+              {
+                "path": "tiny_json_llm/data.py",
+                "bytes": 18760,
+                "sha256": null
+              },
+              {
+                "path": "tiny_json_llm/evaluate.py",
+                "bytes": 6317,
+                "sha256": null
+              },
+              {
+                "path": "tiny_json_llm/infer.py",
+                "bytes": 4260,
+                "sha256": null
+              },
+              {
+                "path": "tiny_json_llm/train.py",
+                "bytes": 17277,
+                "sha256": null
+              },
+              {
+                "path": "tokenizer.json",
+                "bytes": 54877,
+                "sha256": null
+              },
+              {
+                "path": "tokenizer_config.json",
+                "bytes": 2077,
+                "sha256": null
+              },
+              {
+                "path": "training/Tiny_Home_JSON_A100.ipynb",
+                "bytes": 61976,
+                "sha256": null
+              },
+              {
+                "path": "training/audit_dataset.py",
+                "bytes": 4051,
+                "sha256": null
+              },
+              {
+                "path": "training/build_notebook.py",
+                "bytes": 10392,
+                "sha256": null
+              },
+              {
+                "path": "training/prepare_home.py",
+                "bytes": 11051,
+                "sha256": null
+              },
+              {
+                "path": "training/run.json",
+                "bytes": 1024,
+                "sha256": null
+              },
+              {
+                "path": "training/train_log.jsonl",
+                "bytes": 14843,
+                "sha256": null
+              },
+              {
+                "path": "training/verify_pipeline.py",
+                "bytes": 3744,
+                "sha256": null
+              },
+              {
+                "path": "training_metadata.json",
+                "bytes": 1190,
+                "sha256": null
+              },
+              {
+                "path": "verification/downloaded_model_verification.json",
+                "bytes": 1218,
+                "sha256": null
+              },
+              {
+                "path": "verification/release_examples.json",
+                "bytes": 477,
+                "sha256": null
+              },
+              {
+                "path": "verification/verification_report.json",
+                "bytes": 600,
+                "sha256": null
+              },
+              {
+                "path": "weights_sha256.json",
+                "bytes": 94,
+                "sha256": null
+              }
+            ]
+          },
+          "dataset": {
+            "repo_id": "sraivante/home-commands-json-v1",
+            "commit": "8479d12161767c5aabd7dfc097e6f6c41790201a",
+            "files": [
+              {
+                "path": ".gitattributes",
+                "bytes": 133,
+                "sha256": null
+              },
+              {
+                "path": "LICENSE",
+                "bytes": 11357,
+                "sha256": null
+              },
+              {
+                "path": "NOTICE",
+                "bytes": 728,
+                "sha256": null
+              },
+              {
+                "path": "README.md",
+                "bytes": 8459,
+                "sha256": null
+              },
+              {
+                "path": "artifacts/home_commands_training_bundle.zip",
+                "bytes": 19263019,
+                "sha256": "3e0340a0081c3ede31ff8a548c0531470ddaa92486d5f556493b4a50af069b57"
+              },
+              {
+                "path": "data/test.jsonl.gz",
+                "bytes": 1154130,
+                "sha256": "38bbae4cf7fd0347035059e11961fb7c60ef0fb69263e391f9cf6e88981cb69c"
+              },
+              {
+                "path": "data/train.jsonl.gz",
+                "bytes": 9587393,
+                "sha256": "04266e5dbfcb210a5216f723a1bb575fd168382cb06d61260ac670e9c935bb73"
+              },
+              {
+                "path": "data/validation.jsonl.gz",
+                "bytes": 1129727,
+                "sha256": "e37ec83a8454734c9a1ad57cbc492de11d20cba49301c888dde1f9be63860b47"
+              },
+              {
+                "path": "evaluation/build_challenge.py",
+                "bytes": 10121,
+                "sha256": null
+              },
+              {
+                "path": "evaluation/robotics_edge_v1/cases.jsonl",
+                "bytes": 95602,
+                "sha256": null
+              },
+              {
+                "path": "evaluation/robotics_edge_v1/manifest.json",
+                "bytes": 1694,
+                "sha256": null
+              },
+              {
+                "path": "metadata/allowed_outputs.json",
+                "bytes": 2590,
+                "sha256": null
+              },
+              {
+                "path": "metadata/model_config.json",
+                "bytes": 403,
+                "sha256": null
+              },
+              {
+                "path": "metadata/output_schema.json",
+                "bytes": 797,
+                "sha256": null
+              },
+              {
+                "path": "metadata/phrase_groups.json",
+                "bytes": 277559,
+                "sha256": null
+              },
+              {
+                "path": "preparation/audit_dataset.py",
+                "bytes": 4051,
+                "sha256": null
+              },
+              {
+                "path": "preparation/prepare_home.py",
+                "bytes": 11051,
+                "sha256": null
+              },
+              {
+                "path": "preparation/requirements.txt",
+                "bytes": 163,
+                "sha256": null
+              },
+              {
+                "path": "preparation/tiny_json_llm/__init__.py",
+                "bytes": 103,
+                "sha256": null
+              },
+              {
+                "path": "preparation/tiny_json_llm/data.py",
+                "bytes": 18760,
+                "sha256": null
+              },
+              {
+                "path": "release_manifest.json",
+                "bytes": 6223,
+                "sha256": null
+              },
+              {
+                "path": "source/home-commands-3.4M.jsonl.gz",
+                "bytes": 37947929,
+                "sha256": "33edbdedc942ac56444e2196d4b368fc52638eebd6c0cf01264a634261fcf9d1"
+              },
+              {
+                "path": "training_snapshot_manifest.json",
+                "bytes": 12618,
+                "sha256": null
+              }
+            ]
+          }
+        },
+        "remote_weight_path": "model.safetensors",
+        "verified_weight_sha256": "7eed2ed8eb5455f4195cba48ff38b2bc8ff8228cefaf7ee6c477200c776a8ea3"
+      },
+      "publication": "existing model and dataset repositories"
+    }
+  },
+  "scope": "Per-model reproduction projection; the original run manifest hash is preserved in raw results."
+}

edge_benchmarks/rpi5-2026-09-26/cases/poc1_latency.json

@@ -0,0 +1,102 @@
+[
+  {
+    "id": "latency-0",
+    "text": "Please turn on the fan",
+    "expected": {
+      "subject": "fan",
+      "action": "ON"
+    },
+    "match": "subset",
+    "category": "supported_short_command"
+  },
+  {
+    "id": "latency-1",
+    "text": "pankha band karo",
+    "expected": {
+      "subject": "fan",
+      "action": "OFF"
+    },
+    "match": "subset",
+    "category": "supported_short_command"
+  },
+  {
+    "id": "latency-2",
+    "text": "check the water pump status",
+    "expected": {
+      "subject": "motor",
+      "action": "STATUS"
+    },
+    "match": "subset",
+    "category": "supported_short_command"
+  },
+  {
+    "id": "latency-3",
+    "text": "switch off the speaker",
+    "expected": {
+      "subject": "speaker",
+      "action": "OFF"
+    },
+    "match": "subset",
+    "category": "supported_short_command"
+  },
+  {
+    "id": "latency-4",
+    "text": "turn on the light",
+    "expected": {
+      "subject": "light",
+      "action": "ON"
+    },
+    "match": "subset",
+    "category": "supported_short_command"
+  },
+  {
+    "id": "latency-5",
+    "text": "ac chalu karo",
+    "expected": {
+      "subject": "ac",
+      "action": "ON"
+    },
+    "match": "subset",
+    "category": "supported_short_command"
+  },
+  {
+    "id": "latency-6",
+    "text": "turn off the washing machine",
+    "expected": {
+      "subject": "washing_machine",
+      "action": "OFF"
+    },
+    "match": "subset",
+    "category": "supported_short_command"
+  },
+  {
+    "id": "latency-7",
+    "text": "check the sprinkler status",
+    "expected": {
+      "subject": "sprinkler",
+      "action": "STATUS"
+    },
+    "match": "subset",
+    "category": "supported_short_command"
+  },
+  {
+    "id": "latency-8",
+    "text": "turn on the geyser",
+    "expected": {
+      "subject": "geyser",
+      "action": "ON"
+    },
+    "match": "subset",
+    "category": "supported_short_command"
+  },
+  {
+    "id": "latency-9",
+    "text": "switch off the TV",
+    "expected": {
+      "subject": "tv",
+      "action": "OFF"
+    },
+    "match": "subset",
+    "category": "supported_short_command"
+  }
+]

edge_benchmarks/rpi5-2026-09-26/environment.lock.txt

@@ -0,0 +1,30 @@
+certifi==2026.7.22
+charset-normalizer==3.5.1
+filelock==4.0.3
+fsspec==2026.9.0
+hf-xet==1.6.0
+huggingface_hub==0.36.2
+idna==3.20
+Jinja2==3.1.6
+joblib==1.5.3
+MarkupSafe==3.0.3
+mpmath==1.3.0
+networkx==3.7
+numpy==2.3.5
+packaging==26.3
+psutil==7.2.2
+PyYAML==6.0.3
+regex==2026.9.10
+requests==2.34.2
+safetensors==0.8.0
+scikit-learn==1.8.0
+scipy==1.17.0
+setuptools==84.0.0
+sympy==1.14.0
+threadpoolctl==3.7.0
+tokenizers==0.22.1
+torch==2.8.0
+tqdm==4.70.1
+transformers==4.56.2
+typing_extensions==4.16.0
+urllib3==2.8.0

edge_benchmarks/rpi5-2026-09-26/provenance.json

@@ -0,0 +1,257 @@
+{
+  "measurement_revision": "edge-rpi5-20260926",
+  "model": {
+    "repo_id": "sraivante/superfast-tiny-home-robotics-json-1m-v1",
+    "revision": "cf325b380e8ed560a729ec2de09f878a8a917259",
+    "files": [
+      {
+        "bundle_path": "projects/poc1/tiny_json_llm/data.py",
+        "repo_path": "tiny_json_llm/data.py",
+        "sha256": "b1c6dd1207327bc8b9a325391d60762d419589b900ad1329ed21a13df48bc66b",
+        "bytes": 18760,
+        "workspace_source": "POC-1/publication/model/tiny_json_llm/data.py"
+      },
+      {
+        "bundle_path": "projects/poc1/tiny_json_llm/evaluate.py",
+        "repo_path": "tiny_json_llm/evaluate.py",
+        "sha256": "1efd2f862da1fdc6fb17006547de7c53321dbd29aa16c4097daccbfb8dc41e4d",
+        "bytes": 6317,
+        "workspace_source": "POC-1/publication/model/tiny_json_llm/evaluate.py"
+      },
+      {
+        "bundle_path": "projects/poc1/tiny_json_llm/infer.py",
+        "repo_path": "tiny_json_llm/infer.py",
+        "sha256": "2b5074bce3f07127fa254c4ec62e25c6b8ce58743b937cdd301d7bb05128a5c8",
+        "bytes": 4260,
+        "workspace_source": "POC-1/publication/model/tiny_json_llm/infer.py"
+      },
+      {
+        "bundle_path": "projects/poc1/tiny_json_llm/train.py",
+        "repo_path": "tiny_json_llm/train.py",
+        "sha256": "911848ac7816a1a58bbad171a75e1e5e74a9e2790f18492e69d41e0ec4c8ed2a",
+        "bytes": 17277,
+        "workspace_source": "POC-1/publication/model/tiny_json_llm/train.py"
+      },
+      {
+        "bundle_path": "projects/poc1/tiny_json_llm/__init__.py",
+        "repo_path": "tiny_json_llm/__init__.py",
+        "sha256": "e8edab0c5d6fc4202a0b3005dfb4009894ed4c06f216c801943a88f88b7653c2",
+        "bytes": 103,
+        "workspace_source": "POC-1/publication/model/tiny_json_llm/__init__.py"
+      },
+      {
+        "bundle_path": "projects/poc1/best_model/allowed_outputs.json",
+        "repo_path": "allowed_outputs.json",
+        "sha256": "317d35bd27a25e6db66deea50112633b63f7eae907178cc7f50f12dd8ad6aba1",
+        "bytes": 2590,
+        "workspace_source": "POC-1/publication/model/allowed_outputs.json"
+      },
+      {
+        "bundle_path": "projects/poc1/best_model/config.json",
+        "repo_path": "config.json",
+        "sha256": "a66629f39ecb44414aefdf78aa947829e37daf6e6a44be8d710e944ec90ef60a",
+        "bytes": 682,
+        "workspace_source": "POC-1/publication/model/config.json"
+      },
+      {
+        "bundle_path": "projects/poc1/best_model/generation_config.json",
+        "repo_path": "generation_config.json",
+        "sha256": "9b962893b09457be3f8b0d343c8d64d33048443e2e57fbe421cd40d2dec8edf9",
+        "bytes": 132,
+        "workspace_source": "POC-1/publication/model/generation_config.json"
+      },
+      {
+        "bundle_path": "projects/poc1/best_model/manifest.json",
+        "repo_path": "manifest.json",
+        "sha256": "2ead74207a38ad593819da12c52392bad8a273cc62e6842a8278ebffaa561eaa",
+        "bytes": 12618,
+        "workspace_source": "POC-1/publication/model/manifest.json"
+      },
+      {
+        "bundle_path": "projects/poc1/best_model/model.safetensors",
+        "repo_path": "model.safetensors",
+        "sha256": "7eed2ed8eb5455f4195cba48ff38b2bc8ff8228cefaf7ee6c477200c776a8ea3",
+        "bytes": 4380048,
+        "workspace_source": "POC-1/publication/model/model.safetensors"
+      },
+      {
+        "bundle_path": "projects/poc1/best_model/output_schema.json",
+        "repo_path": "output_schema.json",
+        "sha256": "e5c670db2756306cfb58f43e020426a174aef2f60c643ec0cc72920be4aaae86",
+        "bytes": 797,
+        "workspace_source": "POC-1/publication/model/output_schema.json"
+      },
+      {
+        "bundle_path": "projects/poc1/best_model/special_tokens_map.json",
+        "repo_path": "special_tokens_map.json",
+        "sha256": "eae55585dbdfe3c1875015bd0a96dee1b5103a5ab4ef97797de606fb385ea51d",
+        "bytes": 531,
+        "workspace_source": "POC-1/publication/model/special_tokens_map.json"
+      },
+      {
+        "bundle_path": "projects/poc1/best_model/tokenizer.json",
+        "repo_path": "tokenizer.json",
+        "sha256": "0e2e4281172d6ff20e5562d8e0df4c796ca6c0a9e1804067e1b62bdefe38317e",
+        "bytes": 54877,
+        "workspace_source": "POC-1/publication/model/tokenizer.json"
+      },
+      {
+        "bundle_path": "projects/poc1/best_model/tokenizer_config.json",
+        "repo_path": "tokenizer_config.json",
+        "sha256": "66e9e99973752a3b3b6adf621fa1574aa576da1fd2f344b8673196de207da9ad",
+        "bytes": 2077,
+        "workspace_source": "POC-1/publication/model/tokenizer_config.json"
+      },
+      {
+        "bundle_path": "projects/poc1/best_model/training_metadata.json",
+        "repo_path": "training_metadata.json",
+        "sha256": "5fd7ee7df81d8699b853cfa2e33ee70b5ff8172ef8de67b11aee54e8cf73d11f",
+        "bytes": 1190,
+        "workspace_source": "POC-1/publication/model/training_metadata.json"
+      },
+      {
+        "bundle_path": "projects/poc1/best_model/weights_sha256.json",
+        "repo_path": "weights_sha256.json",
+        "sha256": "0d186660bf35658801dea63222e4de0612c237ba13553569535f5b5077824ba1",
+        "bytes": 94,
+        "workspace_source": "POC-1/publication/model/weights_sha256.json"
+      }
+    ],
+    "all_match": true
+  },
+  "training_dataset_snapshot": {
+    "repo_id": "sraivante/home-commands-json-v1",
+    "commit": "8479d12161767c5aabd7dfc097e6f6c41790201a",
+    "files": [
+      {
+        "path": ".gitattributes",
+        "bytes": 133,
+        "sha256": null
+      },
+      {
+        "path": "LICENSE",
+        "bytes": 11357,
+        "sha256": null
+      },
+      {
+        "path": "NOTICE",
+        "bytes": 728,
+        "sha256": null
+      },
+      {
+        "path": "README.md",
+        "bytes": 8459,
+        "sha256": null
+      },
+      {
+        "path": "artifacts/home_commands_training_bundle.zip",
+        "bytes": 19263019,
+        "sha256": "3e0340a0081c3ede31ff8a548c0531470ddaa92486d5f556493b4a50af069b57"
+      },
+      {
+        "path": "data/test.jsonl.gz",
+        "bytes": 1154130,
+        "sha256": "38bbae4cf7fd0347035059e11961fb7c60ef0fb69263e391f9cf6e88981cb69c"
+      },
+      {
+        "path": "data/train.jsonl.gz",
+        "bytes": 9587393,
+        "sha256": "04266e5dbfcb210a5216f723a1bb575fd168382cb06d61260ac670e9c935bb73"
+      },
+      {
+        "path": "data/validation.jsonl.gz",
+        "bytes": 1129727,
+        "sha256": "e37ec83a8454734c9a1ad57cbc492de11d20cba49301c888dde1f9be63860b47"
+      },
+      {
+        "path": "evaluation/build_challenge.py",
+        "bytes": 10121,
+        "sha256": null
+      },
+      {
+        "path": "evaluation/robotics_edge_v1/cases.jsonl",
+        "bytes": 95602,
+        "sha256": null
+      },
+      {
+        "path": "evaluation/robotics_edge_v1/manifest.json",
+        "bytes": 1694,
+        "sha256": null
+      },
+      {
+        "path": "metadata/allowed_outputs.json",
+        "bytes": 2590,
+        "sha256": null
+      },
+      {
+        "path": "metadata/model_config.json",
+        "bytes": 403,
+        "sha256": null
+      },
+      {
+        "path": "metadata/output_schema.json",
+        "bytes": 797,
+        "sha256": null
+      },
+      {
+        "path": "metadata/phrase_groups.json",
+        "bytes": 277559,
+        "sha256": null
+      },
+      {
+        "path": "preparation/audit_dataset.py",
+        "bytes": 4051,
+        "sha256": null
+      },
+      {
+        "path": "preparation/prepare_home.py",
+        "bytes": 11051,
+        "sha256": null
+      },
+      {
+        "path": "preparation/requirements.txt",
+        "bytes": 163,
+        "sha256": null
+      },
+      {
+        "path": "preparation/tiny_json_llm/__init__.py",
+        "bytes": 103,
+        "sha256": null
+      },
+      {
+        "path": "preparation/tiny_json_llm/data.py",
+        "bytes": 18760,
+        "sha256": null
+      },
+      {
+        "path": "release_manifest.json",
+        "bytes": 6223,
+        "sha256": null
+      },
+      {
+        "path": "source/home-commands-3.4M.jsonl.gz",
+        "bytes": 37947929,
+        "sha256": "33edbdedc942ac56444e2196d4b368fc52638eebd6c0cf01264a634261fcf9d1"
+      },
+      {
+        "path": "training_snapshot_manifest.json",
+        "bytes": 12618,
+        "sha256": null
+      }
+    ]
+  },
+  "evaluation": {
+    "kind": "existing frozen stress/regression suite, constrained decoding only",
+    "source": "POC-1\\assessment\\robotics_edge_v1\\cases.jsonl",
+    "sha256": "30cb9a6de18cc12cefcbb6e1aac8a29c7371b0f4ea537e516f38d02b3f417d6c",
+    "notes": "Previously inspected synthetic suite; not a new blind holdout. Original per-case source-overlap metadata retained."
+  },
+  "quality_case_count": 284,
+  "latency_case_count": 10,
+  "case_file_sha256": {
+    "poc1_latency.json": "157cb10e338b20c09e7c383eb9d5ed1f23984ded1984f32f2d228b65ee8e6700",
+    "poc1_quality.json": "a3e20755d442252731b96f8faff4a9d5b4e4074af130f9b4c9063be5e60504ee"
+  },
+  "no_training_or_fine_tuning": true,
+  "copyright": "Copyright (c) 2026 sraivante for original material and selection/arrangement only; Apache License 2.0; third-party terms unchanged."
+}

edge_benchmarks/rpi5-2026-09-26/reproduce.py

@@ -0,0 +1,21 @@
+"""Reproduce this pinned model's Pi benchmark without changing model weights."""
+import argparse, hashlib, json, shutil, subprocess, sys
+from pathlib import Path
+from huggingface_hub import hf_hub_download
+HERE=Path(__file__).resolve().parent
+ap=argparse.ArgumentParser(); ap.add_argument('--threads',type=int,choices=(1,4),default=1); args=ap.parse_args()
+identity=json.loads((HERE/'runtime_identity.json').read_text())
+manifest=json.loads((HERE/'bundle_manifest.json').read_text()); key=next(iter(manifest['models']))
+if key=='poc3' and args.threads!=1: ap.error('This interpreter is single-threaded')
+target=Path.cwd()/('rpi-reproduction-'+key); target.mkdir(exist_ok=True)
+for item in identity['files']:
+    source=Path(hf_hub_download(identity['repo_id'],item['repo_path'],revision=identity['revision']))
+    assert hashlib.sha256(source.read_bytes()).hexdigest()==item['sha256']
+    dest=target/item['bundle_path']; dest.parent.mkdir(parents=True,exist_ok=True); shutil.copyfile(source,dest)
+for name in ('benchmark.py','bundle_manifest.json'):
+    shutil.copyfile(HERE/name,target/name)
+for source in (HERE/'cases').glob('*.json'):
+    dest=target/'cases'/source.name; dest.parent.mkdir(exist_ok=True); shutil.copyfile(source,dest)
+command=[sys.executable,'-u',str(target/'benchmark.py'),'--model',key,'--threads',str(args.threads),'--out',str(target/('result_t'+str(args.threads)+'.json'))]
+if args.threads==1: command.append('--quality')
+subprocess.run(command,check=True)

edge_benchmarks/rpi5-2026-09-26/runtime_identity.json

@@ -0,0 +1,119 @@
+{
+  "repo_id": "sraivante/superfast-tiny-home-robotics-json-1m-v1",
+  "revision": "cf325b380e8ed560a729ec2de09f878a8a917259",
+  "files": [
+    {
+      "bundle_path": "projects/poc1/tiny_json_llm/data.py",
+      "repo_path": "tiny_json_llm/data.py",
+      "sha256": "b1c6dd1207327bc8b9a325391d60762d419589b900ad1329ed21a13df48bc66b",
+      "bytes": 18760,
+      "workspace_source": "POC-1/publication/model/tiny_json_llm/data.py"
+    },
+    {
+      "bundle_path": "projects/poc1/tiny_json_llm/evaluate.py",
+      "repo_path": "tiny_json_llm/evaluate.py",
+      "sha256": "1efd2f862da1fdc6fb17006547de7c53321dbd29aa16c4097daccbfb8dc41e4d",
+      "bytes": 6317,
+      "workspace_source": "POC-1/publication/model/tiny_json_llm/evaluate.py"
+    },
+    {
+      "bundle_path": "projects/poc1/tiny_json_llm/infer.py",
+      "repo_path": "tiny_json_llm/infer.py",
+      "sha256": "2b5074bce3f07127fa254c4ec62e25c6b8ce58743b937cdd301d7bb05128a5c8",
+      "bytes": 4260,
+      "workspace_source": "POC-1/publication/model/tiny_json_llm/infer.py"
+    },
+    {
+      "bundle_path": "projects/poc1/tiny_json_llm/train.py",
+      "repo_path": "tiny_json_llm/train.py",
+      "sha256": "911848ac7816a1a58bbad171a75e1e5e74a9e2790f18492e69d41e0ec4c8ed2a",
+      "bytes": 17277,
+      "workspace_source": "POC-1/publication/model/tiny_json_llm/train.py"
+    },
+    {
+      "bundle_path": "projects/poc1/tiny_json_llm/__init__.py",
+      "repo_path": "tiny_json_llm/__init__.py",
+      "sha256": "e8edab0c5d6fc4202a0b3005dfb4009894ed4c06f216c801943a88f88b7653c2",
+      "bytes": 103,
+      "workspace_source": "POC-1/publication/model/tiny_json_llm/__init__.py"
+    },
+    {
+      "bundle_path": "projects/poc1/best_model/allowed_outputs.json",
+      "repo_path": "allowed_outputs.json",
+      "sha256": "317d35bd27a25e6db66deea50112633b63f7eae907178cc7f50f12dd8ad6aba1",
+      "bytes": 2590,
+      "workspace_source": "POC-1/publication/model/allowed_outputs.json"
+    },
+    {
+      "bundle_path": "projects/poc1/best_model/config.json",
+      "repo_path": "config.json",
+      "sha256": "a66629f39ecb44414aefdf78aa947829e37daf6e6a44be8d710e944ec90ef60a",
+      "bytes": 682,
+      "workspace_source": "POC-1/publication/model/config.json"
+    },
+    {
+      "bundle_path": "projects/poc1/best_model/generation_config.json",
+      "repo_path": "generation_config.json",
+      "sha256": "9b962893b09457be3f8b0d343c8d64d33048443e2e57fbe421cd40d2dec8edf9",
+      "bytes": 132,
+      "workspace_source": "POC-1/publication/model/generation_config.json"
+    },
+    {
+      "bundle_path": "projects/poc1/best_model/manifest.json",
+      "repo_path": "manifest.json",
+      "sha256": "2ead74207a38ad593819da12c52392bad8a273cc62e6842a8278ebffaa561eaa",
+      "bytes": 12618,
+      "workspace_source": "POC-1/publication/model/manifest.json"
+    },
+    {
+      "bundle_path": "projects/poc1/best_model/model.safetensors",
+      "repo_path": "model.safetensors",
+      "sha256": "7eed2ed8eb5455f4195cba48ff38b2bc8ff8228cefaf7ee6c477200c776a8ea3",
+      "bytes": 4380048,
+      "workspace_source": "POC-1/publication/model/model.safetensors"
+    },
+    {
+      "bundle_path": "projects/poc1/best_model/output_schema.json",
+      "repo_path": "output_schema.json",
+      "sha256": "e5c670db2756306cfb58f43e020426a174aef2f60c643ec0cc72920be4aaae86",
+      "bytes": 797,
+      "workspace_source": "POC-1/publication/model/output_schema.json"
+    },
+    {
+      "bundle_path": "projects/poc1/best_model/special_tokens_map.json",
+      "repo_path": "special_tokens_map.json",
+      "sha256": "eae55585dbdfe3c1875015bd0a96dee1b5103a5ab4ef97797de606fb385ea51d",
+      "bytes": 531,
+      "workspace_source": "POC-1/publication/model/special_tokens_map.json"
+    },
+    {
+      "bundle_path": "projects/poc1/best_model/tokenizer.json",
+      "repo_path": "tokenizer.json",
+      "sha256": "0e2e4281172d6ff20e5562d8e0df4c796ca6c0a9e1804067e1b62bdefe38317e",
+      "bytes": 54877,
+      "workspace_source": "POC-1/publication/model/tokenizer.json"
+    },
+    {
+      "bundle_path": "projects/poc1/best_model/tokenizer_config.json",
+      "repo_path": "tokenizer_config.json",
+      "sha256": "66e9e99973752a3b3b6adf621fa1574aa576da1fd2f344b8673196de207da9ad",
+      "bytes": 2077,
+      "workspace_source": "POC-1/publication/model/tokenizer_config.json"
+    },
+    {
+      "bundle_path": "projects/poc1/best_model/training_metadata.json",
+      "repo_path": "training_metadata.json",
+      "sha256": "5fd7ee7df81d8699b853cfa2e33ee70b5ff8172ef8de67b11aee54e8cf73d11f",
+      "bytes": 1190,
+      "workspace_source": "POC-1/publication/model/training_metadata.json"
+    },
+    {
+      "bundle_path": "projects/poc1/best_model/weights_sha256.json",
+      "repo_path": "weights_sha256.json",
+      "sha256": "0d186660bf35658801dea63222e4de0612c237ba13553569535f5b5077824ba1",
+      "bytes": 94,
+      "workspace_source": "POC-1/publication/model/weights_sha256.json"
+    }
+  ],
+  "all_match": true
+}

release_manifest.json

@@ -36,10 +36,26 @@
       "bytes": 133,
       "sha256": "8c6dce8d82b0d8705faef37c0a2b838fd47a481f814682d67c369618ac324100"
     },
+    "LICENSE": {
+      "bytes": 11357,
+      "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+    },
+    "NOTICE": {
+      "bytes": 728,
+      "sha256": "3dce4a2870f76ab3b86cc84067bb017d32e8b726892fc87a8ca4110cac79219b"
+    },
+    "README.md": {
+      "bytes": 13219,
+      "sha256": "24dd95bd6c005414bf54860b8c53a1da9a42dc1cb367eaa215af729361ba68a8"
+    },
     "allowed_outputs.json": {
       "bytes": 2590,
       "sha256": "317d35bd27a25e6db66deea50112633b63f7eae907178cc7f50f12dd8ad6aba1"
     },
+    "assessment/RASPBERRY_PI.md": {
+      "bytes": 709,
+      "sha256": "44e705c5bbf3c3488738170fc831418543d572a4a929d4c58bfeeb721b6d192d"
+    },
     "assessment/benchmark_device.py": {
       "bytes": 6302,
       "sha256": "4a188470cb99e67fb804bb0fbdc3def5ae6751fdf686ae15476604d4862ab552"
@@ -52,9 +68,9 @@
       "bytes": 5579,
       "sha256": "8df51447b3b6416bc551bced731a4ea732a32a13a2693247ae239f71450356f4"
     },
-    "assessment/RASPBERRY_PI.md": {
-      "bytes": 709,
-      "sha256": "44e705c5bbf3c3488738170fc831418543d572a4a929d4c58bfeeb721b6d192d"
+    "assessment/robotics_edge_v1/REPORT.md": {
+      "bytes": 10707,
+      "sha256": "64c6e4aa8a79ef4ca070fc72682fecff09cd20bc15f5c084b60280a5a6ea270d"
     },
     "assessment/robotics_edge_v1/cases.jsonl": {
       "bytes": 95602,
@@ -84,14 +100,62 @@
       "bytes": 389133,
       "sha256": "71cc0ac4c6a6195863a25b2788a21d839415058eeca5cc4a92091487dc496d7b"
     },
-    "assessment/robotics_edge_v1/REPORT.md": {
-      "bytes": 10707,
-      "sha256": "64c6e4aa8a79ef4ca070fc72682fecff09cd20bc15f5c084b60280a5a6ea270d"
-    },
     "config.json": {
       "bytes": 682,
       "sha256": "a66629f39ecb44414aefdf78aa947829e37daf6e6a44be8d710e944ec90ef60a"
     },
+    "edge_benchmarks/rpi5-2026-09-26/REPORT.md": {
+      "bytes": 6252,
+      "sha256": "6fc28a537a7261320a96b93f0a55108904d0abca69419b690f336b86af8de990"
+    },
+    "edge_benchmarks/rpi5-2026-09-26/benchmark.py": {
+      "bytes": 13816,
+      "sha256": "2a2a0694235642db38ffdbfe3838d5318224309cb4161b85e33486c1743f2061"
+    },
+    "edge_benchmarks/rpi5-2026-09-26/bundle_manifest.json": {
+      "bytes": 17568,
+      "sha256": "29754d52abb0f2201d55819186df85d0df8f733a740d2e128b2830f587027b38"
+    },
+    "edge_benchmarks/rpi5-2026-09-26/cases/poc1_latency.json": {
+      "bytes": 2180,
+      "sha256": "157cb10e338b20c09e7c383eb9d5ed1f23984ded1984f32f2d228b65ee8e6700"
+    },
+    "edge_benchmarks/rpi5-2026-09-26/cases/poc1_quality.json": {
+      "bytes": 193903,
+      "sha256": "a3e20755d442252731b96f8faff4a9d5b4e4074af130f9b4c9063be5e60504ee"
+    },
+    "edge_benchmarks/rpi5-2026-09-26/environment.lock.txt": {
+      "bytes": 506,
+      "sha256": "0dae9933461ff1551edb8afdc7cc89e1b63dacddcd1dcca33d4be07b7e5bd0ba"
+    },
+    "edge_benchmarks/rpi5-2026-09-26/provenance.json": {
+      "bytes": 9358,
+      "sha256": "f5a12e015ad46ccd193afe2cd9aa7e2ed757384e07367578256fd328ea0e874c"
+    },
+    "edge_benchmarks/rpi5-2026-09-26/readings.csv": {
+      "bytes": 103401,
+      "sha256": "1c487fd04aa8f1a608aa2f81f4ca275a7bdc2bd121e0bd2cd72131b39eeae7ff"
+    },
+    "edge_benchmarks/rpi5-2026-09-26/reproduce.py": {
+      "bytes": 1503,
+      "sha256": "1fb5bb68f46b02329ecccb66f3de20b301f66e0d41c4eaba53fa7e3224c982ee"
+    },
+    "edge_benchmarks/rpi5-2026-09-26/results/poc1_t1.json": {
+      "bytes": 542969,
+      "sha256": "67d94f301dddf46c0899ce9161c1a3ccab66faca9ec08ebc80b874a908f438f6"
+    },
+    "edge_benchmarks/rpi5-2026-09-26/results/poc1_t4.json": {
+      "bytes": 230245,
+      "sha256": "afba1ed7e145a64149508e3b7f61264ea0e7a5155acf06ef7cb0a2c91f2af141"
+    },
+    "edge_benchmarks/rpi5-2026-09-26/runtime_identity.json": {
+      "bytes": 5078,
+      "sha256": "d5b81efe500eaa4550833a6dd3883e7f9d2a03a9a7e77932386cffcba81b3780"
+    },
+    "edge_benchmarks/rpi5-2026-09-26/temperature_latency.png": {
+      "bytes": 154941,
+      "sha256": "b84806634d248d984b85ec0603a61be8ade6b6738c59f7c4c1f2f401b85d586d"
+    },
     "evaluation/metrics.json": {
       "bytes": 10936,
       "sha256": "9f53479d2b67bd06fc3a5b56f2dba2856bcb11778cef1fe0afa0e0a39a99d6c9"
@@ -108,10 +172,6 @@
       "bytes": 132,
       "sha256": "9b962893b09457be3f8b0d343c8d64d33048443e2e57fbe421cd40d2dec8edf9"
     },
-    "LICENSE": {
-      "bytes": 11357,
-      "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
-    },
     "manifest.json": {
       "bytes": 12618,
       "sha256": "2ead74207a38ad593819da12c52392bad8a273cc62e6842a8278ebffaa561eaa"
@@ -120,18 +180,10 @@
       "bytes": 4380048,
       "sha256": "7eed2ed8eb5455f4195cba48ff38b2bc8ff8228cefaf7ee6c477200c776a8ea3"
     },
-    "NOTICE": {
-      "bytes": 728,
-      "sha256": "3dce4a2870f76ab3b86cc84067bb017d32e8b726892fc87a8ca4110cac79219b"
-    },
     "output_schema.json": {
       "bytes": 797,
       "sha256": "e5c670db2756306cfb58f43e020426a174aef2f60c643ec0cc72920be4aaae86"
     },
-    "README.md": {
-      "bytes": 11097,
-      "sha256": "b282fe69815c7991578042ed038e0297933cbdbcd2cd24e3f673eb7bb949e1e1"
-    },
     "requirements.txt": {
       "bytes": 111,
       "sha256": "e565b0c29221c7e17347cdbaeaa7cba2efee571d2ca8f742d4882925705db460"
@@ -168,6 +220,10 @@
       "bytes": 2077,
       "sha256": "66e9e99973752a3b3b6adf621fa1574aa576da1fd2f344b8673196de207da9ad"
     },
+    "training/Tiny_Home_JSON_A100.ipynb": {
+      "bytes": 61976,
+      "sha256": "ed056ea07f969f1983b1d5efa98030df5ce72ab571b0369616b3e33b6a5d8365"
+    },
     "training/audit_dataset.py": {
       "bytes": 4051,
       "sha256": "687b8c1cfabb9031eb9ddc901de47b4c2115b77d4aa22c6b35912556ae7f9f4e"
@@ -184,10 +240,6 @@
       "bytes": 1024,
       "sha256": "1cafbddca61420914c6435de449af55007fd8ec7cc06ba58b399ffc9a7d113ea"
     },
-    "training/Tiny_Home_JSON_A100.ipynb": {
-      "bytes": 61976,
-      "sha256": "ed056ea07f969f1983b1d5efa98030df5ce72ab571b0369616b3e33b6a5d8365"
-    },
     "training/train_log.jsonl": {
       "bytes": 14843,
       "sha256": "c371de9912ae1d6e589551685c20735be1ff5177271d375eeb69ba5fc7195075"
@@ -219,5 +271,11 @@
   },
   "documentation_patch": "Repository renamed at the publisher's request; model title, usage and linked dataset references updated. Weights, runtime code and all training/evaluation data are unchanged.",
   "previous_release_commit": "89ccd2a58be3831640b13e9e1c63d1234d25ea39",
-  "renamed_from": "sraivante/tiny-home-json-1m-v1"
+  "renamed_from": "sraivante/tiny-home-json-1m-v1",
+  "edge_measurement_update": {
+    "revision": "edge-rpi5-20260926",
+    "date": "2026-09-26",
+    "weights_and_training_data_changed": false,
+    "files": "edge_benchmarks/rpi5-2026-09-26"
+  }
 }