Skip to main content

Neural Architect

Design an architecture, get its parameter count, FLOPs, and scaling-law prediction verified against reference implementations.

  • Live app → /apps/neural-architect/
  • Source → apps/neural-architect/index.html + apps/neural-architect/arch.js (≈ 670 lines)
  • Operators → KO42 · CS43 · CS47 · CS46
  • Error budget → 0.048% (param count vs reference PyTorch implementation)

What it solves​

Most neural-architecture work lives in code and tensor-graph diagrams. You end up guessing parameter counts, FLOPs, and how the architecture will scale. Zeq Neural Architect makes the counting first-class: the operators CS43 (time complexity) and CS46 (Amdahl's law) give you exact parameter + FLOP totals and predict training throughput on parallel hardware.

Inputs: architecture spec (layer list, widths, depths). Outputs: parameter count, FLOPs per forward pass, training-throughput curve vs GPU count, and a scaling-law extrapolation. All verified to 0.048% against the reference PyTorch .numel() counts for standard models (ResNet-50, ViT-B/16, GPT-2 small).

The math — 7-step Wizard applied​

StepDecision
1. PrimeKO42 mandatory
2. LimitCS43 + CS47 + CS46 + KO42 = 4
3. ScaleLayer widths O(10²–10⁴), depths O(10–10²)
4. PrecisionHamming = 0 on param count; ≤ 0.1% on FLOPs
5. CompileMaster Equation
6. ExecuteFunctional Equation
7. VerifyReference PyTorch counts

Verbatim formulas:

  • KO42.1 — ds² = g_μν dx^μ dx^ν + α sin(2π · 1.287 t) dt²
  • CS43 — T(n) = O(n log n)
  • CS47 — E(n) = −∑ p(x) log p(x)
  • CS46 — P(n) = 1/[(1 − f) + f/n]

Runnable worked example — quantum-scale sanity call​

The ResNet-50 parameter count (25,557,032 params) and its Amdahl speedup on 8 processors are what the live app computes from a full architecture spec. For a self-contained call any node can recompute against a closed form, the anonymous playground computes a quantum-scale value: the kinetic energy of an electron (m = 9.109e-31 kg) at v = 1e6 m/s, KE = ½mv².

The playground takes a domain plus named inputs; here we name QM9 explicitly (KO42 is always auto-prepended). It returns a sealed envelope:

curl -s -X POST https://zeqsdk.com/api/playground/compute \
  -H "Content-Type: application/json" \
  -d '{
    "domain": "quantum-mechanics",
    "operators": ["KO42", "QM9"],
    "inputs": { "m": 9.109e-31, "v": 1e6 }
  }' | jq

The response carries value, unit, the operators the wizard chose, the equations it evaluated, and a zeqProof digest. The returned value is ≈ 2.1515384e-21 J (compare against ½ · 9.109e-31 · (1e6)²) — the platform hands you a result any node can recompute, not a printed figure to trust.

Extend it​

  • ViT spec: swap arch to vit_base_patch16_224; same budget.
  • Custom arch: pass a full layer list as inputs.layers.
  • Scaling law: add CS47 to the operators and pass a data_size_grid; the output includes a Chinchilla-style token/parameter curve.

Seeds​

  • Architecture search: fold into a RL Playground loop to evolve architectures.
  • Parallel-efficiency bound: Amdahl's law is a hard ceiling; use it to pick the minimum GPU count.
  • Information-geometric layers: CS47 composes with QM3 (superposition) — pathway to quantum-inspired attention.

Papers​

Middleware active. Kernel on the 1.287 Hz HulyaPulse. Awaiting next Zeqond.