Talos-XII: hand-written autograd + small RL/MLP stack in Rust, applied to gacha probability modeling (no tch-rs/ndarray/PyTorch) — looking for benchmark help on ARM/AVX-512/GPU [P]

What it is

Talos-XII is a CLI simulator for the gacha system in Arknights: Endfield. Rather than sampling from a static probability table, it trains a small set of neural nets to model environment uncertainty and pull-decision policy, then uses them to answer questions a static table can’t easily express — e.g. “as a F2P player, what’s my probability of getting the rate-up unit on free currency alone?” or “given my current pity count, should I keep pulling or save for the next banner?”
Models (trained on first run, ~30-45s, then cached to disk)
• EnvNet — small MLP fitting an environment noise/bias distribution, sampled per simulation
• Luck Optimizer — neural optimizer over a 32-dim engineered feature vector (pity progress, streaks, interaction terms)
• Dueling DQN — discrete pull/wait decision
• PPO actor-critic — with an MLA (latent-attention) transformer for continuous strategy
Everything underneath is hand-written, no external ML framework:
• Custom autograd engine (matmul, conv2d, pooling, norms, gradient-checked backward passes)
• Runtime SIMD dispatch: scalar → AVX2 → AVX2+FMA → AVX-512, NEON on ARM64
• Rayon-parallelized sims (~10k+/sec on my laptop)
• BF16 inference caches
• Optional PyO3 bridge (import talos_xii as tx) for writing training scripts without NumPy/PyTorch
• 142 tests, CI on Linux/Windows/macOS with ARM64 cross-compile, single static binary, MIT

The part I’m not confident about
There’s a component I call ACHF (Adaptive Cache-aware Hyper-Connections): it blends a dense path with a pruned sparse path via a gradient-sensitive gate, adds a manifold (Sinkhorn) weight projection, and switches between cached/sparse/dense execution paths based on measured latency. Loosely inspired by manifold-constrained hyper-connections, but aimed at a different regime — compact RL policies running on CPU inside a single binary, not large-scale training.
I don’t yet know if the speed/accuracy tradeoff holds up outside my own machine. I’m treating it as an open experiment, not a result.

Where I’d like help
I only have access to my own hardware, so my benchmark coverage is thin. There’s an automated benchmark suite in the repo that reports mean ± std with 95% CIs, per-path latency distributions (p50/p90/p99), training curves, and raw CSVs — instructions are in the README.
If anyone’s willing to run it on a different CPU (AVX-512, ARM NEON) or GPU setup, I’d genuinely appreciate the data — negative results (ACHF not helping on your hardware) are just as useful to me as positive ones.

Repo: github.com/zayokami/Talos-XII
Solo project, built to learn Rust + ML fundamentals from scratch. Happy to answer questions about any of the implementation details.