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 — ResNet-50 spec​

The anonymous playground takes a domain plus named inputs and lets the seven-step wizard pick the operators (always KO42 + the domain fit). It returns a sealed envelope:

curl -s -X POST https://zeqsdk.com/api/playground/compute \
  -H "Content-Type: application/json" \
  -d '{
    "domain": "computer-science",
    "inputs": { "width": 224, "height": 224, "channels": 3, "processors": 8 }
  }' | jq

The response carries value, unit, the operators the wizard chose, the equations it evaluated, and a zeqProof digest. Compare the returned value against the known ResNet-50 reference (25,557,032 parameters; Amdahl speedup on 8 processors) yourself — 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.