🏭
Your fab’s DFM rules
JLCPCB, PCBWay, and a mil-spec fab have different minimum trace widths, via sizes, and stackup requirements. Your model learns your fab’s specific tolerances — not an averaged approximation.
Why a custom model
Generic models score generic work.
Generic models score generic work.
Your work isn’t generic.
A model trained on publicly scraped PCB data has no concept of your fab’s tolerances, your component library, or your DFM rules. It systematically mismatches against your engineers’ judgement. A custom model does not.
📚
Your component library
Your approved parts list, preferred footprints, and component derating rules are invisible to a generic model. A custom model knows what correct component selection means in your organization.
🧑🔬
Senior engineer judgement
Calibrated against 200+ designs your own senior engineers annotated. The model reflects what you consider a B-grade layout versus an A-grade one — not what internet forums decided.
🔒
Impossible to replicate
Your model is a private artifact trained on non-public data. Competitors cannot reverse-engineer your scoring logic. It becomes a genuine technical moat for your assessment process.
⬡
SRHN trained on your knowledge
Ingest your design guidelines, application notes, and lessons-learned into your private SRHN graph. PAC-Bayes bounds and causal chains are grounded in your standards, not generic physics data.
📈
Gets smarter with use
Every design reviewed contributes to the training corpus. Every engineer rating a score improves the model. The learning flywheel runs continuously — your model compounds over time.
Process
How your custom model is built
Five steps from your raw designs to a deployed, versioned, private scoring model. No ML expertise required from your team.
01
Ingest your design corpus
Upload your existing .kicad_pcb, .kicad_sch, SPICE netlists, and .step files. The universal ingester parses all formats, extracts 192-dim multimodal features, and quality-filters automatically. Minimum useful corpus: 50 designs.
# Upload your design library
python scripts/ingest_dataset.py --local ./your_pcb_library/
# 847 designs processed, 721 passed quality filter
# data/corpus/custom_org.parquet written
02
Expert annotation session
Your senior engineers use the ML System page to annotate 200+ designs. Each annotation takes 3–5 minutes: score 6 competencies, add a rationale. The interface surfaces designs where the current model is most uncertain — maximally efficient use of your experts’ time.
200 annotations = first retrain500 = production accuracy1000+ = expert parity
03
Ingest your standards into SRHN
Feed your internal design guidelines, IPC compliance docs, and lessons-learned files into your private SRHN knowledge graph. The engine learns causal relationships specific to your engineering context.
curl -X POST /api/v1/srhn/ingest
-d '{"text": "$(cat your_design_guide.txt)"}'
# 2,841 nodes added to your private graph
04
Fine-tune the scoring model
The pipeline retrains the GBM ensemble — and optionally the GATv2 GNN — on your annotated corpus. Real data is upsampled 10x. Each model version is locked to a content hash and stored as a private artifact.
python scripts/train_model.py --retrain-real --org your_org
# 847 org designs + 4,235 synthetic
# val_r=0.961 · EXCELLENT
# golden eval: MAE=4.2 · grade_acc=78% · PASS
05
Deploy and monitor
Your model runs at a private API endpoint. Every review uses your version. The eval dashboard shows model health, drift alerts, and next annotation actions in real time. Model compounds automatically as usage grows.
What your custom model adds
Higher accuracy on your designs
Generic: r=0.942. After 500 org annotations: expected r→0.97+ on your specific design patterns.
Org-calibrated competency weights
For medical devices, thermal_management matters more than documentation. Your weights reflect your priorities.
Private SRHN knowledge graph
PAC-Bayes bounds derived from your knowledge density. Causal chains reference your standards, not generic IPC phrasing.
Immutable audit trail
Every score: model version hash + feature vector + SRHN state. Legally defensible for hiring and certification.
Golden test set locked to your standards
25 expert-triple-annotated designs from your corpus. Every future model is gated before deployment.
Expected accuracy trajectory
Spearman r as expert annotations accumulate
Baseline (synthetic)
0.942
50 org annotations
~0.955
200 annotations
~0.963
500 annotations
~0.971
+ GNN trained
~0.981
GNN training requires A100, ~8 hours on your corpus.
Comparison
Generic vs custom model
Who builds custom models
Use cases
🏚
Hardware companies
Ingest your internal design review checklist, have senior EEs annotate candidate designs, deploy as a technical screening tool for hardware engineering hires.
🎓
Bootcamps & universities
Train on your curriculum’s projects and instructor annotations. The model grades student PCB submissions against the specific skills your program teaches.
📋
Certification bodies
IPC CID, IPC CIS, or custom certification. Upload reference designs with known scores. The model becomes the automated, auditable, consistent grader.
🔬
Defense & aerospace
MIL-STD-461, DO-160, IPC-6012 Class 3 requirements are highly specific. Your model learns exactly what acceptable means for your program.
Technical architecture
What gets customized at each layer
Every layer can be fine-tuned to your data. Here is what changes and what stays fixed.
GBM Scoring Model
Always customizedRetrained from scratch on your annotated corpus. Competency weights, feature importance, and score thresholds all adapt to your data. Model artifact is content-hashed and private.
# Your retrain pipeline
EngineeringScorer.fit(X_org, Y_org,
weights=org_weights,
n_estimators=600)
SRHN Knowledge Graph
Always customizedYour private SRHN instance ingests your design guidelines and app notes. PAC-Bayes bounds come from your knowledge graph density — grounded in your standards.
./srhn4_train --ingest design_guide.txt \
--ingest ipc_class3.txt --epochs 25
# Your private knowledge graph ready
GATv2 GNN Embedding
Optional (GPU needed)After pretraining on the general corpus, the 6-layer GATv2 can be fine-tuned on your design graphs. The 256-dim embeddings capture circuit topology patterns specific to your product category.
Requires: A100 (80GB), ~8 hours fine-tuning.
Output: 256-dim embeddings tuned to your topologies.
Output: 256-dim embeddings tuned to your topologies.
Feature Extraction Layer
Fixed (universal)The 192-dim feature extractor is shared. It is the measurement layer — deterministic, physics-grounded. What gets customized is how your model weights and interprets these features.
PCB:48SCH:32SIM:24MCAD:48BEH:32SRHN:8