EdgeSpectra on Arm

FTIR spectral agent retrieval kernel optimized for Arm64 — real cross-architecture benchmark, reproducible on GitHub Actions ARM runners.

Comment

What it does

EdgeSpectra on Arm ports the FTIR spectral retrieval kernel (the hot path of the FTIR.fun scientific agent) to Arm64 and proves it with a reproducible, cross-architecture benchmark running on free GitHub Actions ARM runners (ubuntu-24.04-arm).

The benchmark measures the exact hot path a scientific AI agent hits on every sample: a 132,947-spectrum peak-position library index, Top-10 similarity retrieval, 100 queries.

Real measured results (GitHub Actions, 2026-08-09, run 31317406525):

Metric ARM64 (aarch64) x86_64 ARM vs x86
Library load 5.98 s 7.23 s -17%
p50 query latency 1752.3 ms 2396.3 ms -27%
p95 query latency 1759.9 ms 2409.6 ms -27%
Throughput 0.57 qps 0.42 qps +36%

Methodology is fully disclosed: fixed-seed synthetic peak data (the production library is license-restricted), same Python 3.12.13 on both architectures, one command to reproduce: python bench.py --spectra 132947 --queries 100.

Inspiration

Scientific agents should run on the hardware people actually deploy — Arm cloud and edge. Optimization claims without reproducible fixtures are marketing; this project is fixtures-first: same seed, same library, same runner family, both architectures, published in CI logs.

How it was built

  • bench.py: spectral retrieval kernel micro-benchmark (peak-position similarity scoring, Top-N)
  • GitHub Actions matrix: ubuntu-24.04 + ubuntu-24.04-arm run the identical job on every push
  • Honest disclosure: synthetic fixed-seed data (production library is license-restricted); benchmark measures CPU/memory behavior of the retrieval kernel, not a claim about the production dataset

Challenges

Keeping the benchmark honest: same seed, same library revision, same Python version on both architectures; avoiding cherry-picked runs (results are from CI logs, not local runs).

Accomplishments

  • Reproducible ARM64 vs x86_64 comparison in CI (run 31317406525)
  • ARM64 outperforms x86_64 by 27% on p95 latency in this kernel (as-is, pure Python)
  • Next steps documented: numpy vectorization + Arm-friendly build flags for further gains

What's next

Vectorized scoring, ArmNN/ONNX for on-device inference, and extending the fixture set to the full production pipeline (peak detection + retrieval + evidence gate).

Built With

Share this project:

Updates