Dataset card, protocol, figures

PROTOCOL.md

@@ -0,0 +1,76 @@
+# Evaluation protocol
+
+How submissions to the benchmarks are scored. The reference implementation in `emval/metrics.py` is the specification — this document explains it; where prose and code could ever disagree, the code wins. Protocol version: 1.0.0.
+
+## Aggregation
+
+Every metric reduces one board to one scalar, then boards are averaged with equal weight — the board is the unit of generalization, so a board with many ports or probes counts no more than a small one. For the near-field metrics, all of the board's probes are pooled across its driven ports and frequencies before the reduction.
+
+Reported per split (`public`, `private_standard`, `private_challenge`); the public scorer also breaks results down by port count.
+
+## EMVal-SP-v1 metrics
+
+For one board, let $S_{ijf}$ be the true complex S-parameter (output port $i$, driven port $j$, frequency $f$), $\hat S_{ijf}$ the prediction, and $N$ the number of $(i,j,f)$ entries.
+
+`real_imag_rmse` — error in the complex plane, linear scale:
+
+$$
+\mathrm{rmse} = \sqrt{\frac{1}{2N} \sum_{ijf} \left[ (\Re\hat S - \Re S)^2 + (\Im\hat S - \Im S)^2 \right]}
+$$
+
+The $\tfrac{1}{2}$ averages over the real and imaginary components, so the number reads as a per-component RMS deviation. A small numerical floor under the square root means a perfect submission scores $10^{-4}$, not 0.
+
+`mag_wmae` — weighted mean absolute error of the magnitude in dB. With $M = 20\log_{10}|S|$, $\hat M = 20\log_{10}|\hat S|$, and a sigmoid gate
+
+$$
+w_{ijf} = \sigma\!\left(\frac{M_{ijf} - N_0}{\tau}\right), \qquad N_0 = -20\ \mathrm{dB},\ \tau = 2\ \mathrm{dB},
+$$
+
+$$
+\mathrm{mag\_wmae} = \frac{\sum_{ijf} w_{ijf}\, |\hat M_{ijf} - M_{ijf}|}{\sum_{ijf} w_{ijf}}.
+$$
+
+`ph_wmae` — the same weighted mean over phase error, wrapped to one period so a $-179^\circ$ vs $+179^\circ$ disagreement counts as $2^\circ$, not $358^\circ$:
+
+$$
+\mathrm{ph\_wmae} = \frac{\sum_{ijf} w_{ijf}\, \left|\mathrm{wrap}(\arg\hat S_{ijf} - \arg S_{ijf})\right|}{\sum_{ijf} w_{ijf}}, \qquad \mathrm{wrap}(\theta) = \mathrm{atan2}(\sin\theta, \cos\theta).
+$$
+
+Why the gate: S-parameter sweeps contain deep nulls — frequencies where $|S|$ drops tens of dB below unity. At a null, magnitude in dB and phase are numerically defined but physically irrelevant: a 3 dB error at $-60$ dB changes nothing an engineer cares about, while the same error at $-3$ dB is a different circuit. An ungated dB/phase MAE would let nulls dominate the score. The sigmoid keeps full weight on entries near 0 dB, rolls off smoothly around $-20$ dB, and effectively removes entries far below it — and the *true* magnitude drives the gate, so a submission cannot influence its own weighting. Phase uses the same gate so both numbers describe the same population of entries. `real_imag_rmse` stays ungated as the complement: in the linear complex plane, nulls are near zero and contribute naturally little.
+
+## EMVal-NF-v1 metrics
+
+For one board, let $\mathbf{E}_p \in \mathbb{C}^3$ be the true field at probe $p$, where $p$ runs over the board's pooled probe set — every probe at every driven port and frequency, $P$ in total — and $\hat{\mathbf{E}}_p$ the prediction; identically for $\mathbf{H}$. Three metrics per field axis, each answering a different question; each is one reduction over the pooled set.
+
+`rel_l2_E`, `rel_l2_H` — relative L2 error over the board's pooled probes:
+
+$$
+\mathrm{rel\_l2} = \frac{\left( \sum_p \lVert \hat{\mathbf{E}}_p - \mathbf{E}_p \rVert_2^2 \right)^{1/2}}{\left( \sum_p \lVert \mathbf{E}_p \rVert_2^2 \right)^{1/2}}.
+$$
+
+The numerator sums squared absolute errors and the normalization happens once at the end, so the metric is dominated by the probes where the true field is large — it asks "is the field right where the field is large". Pooling across frequencies means high-field frequencies dominate low-field ones for the same reason.
+
+`local_q50_E`, `local_q50_H` — the median over the pooled probes of the per-point relative error:
+
+$$
+e_p = \frac{\lVert \hat{\mathbf{E}}_p - \mathbf{E}_p \rVert_2}{\lVert \mathbf{E}_p \rVert_2}, \qquad \mathrm{local\_q50} = \mathrm{median}_p\, e_p.
+$$
+
+Each probe is normalized by its own magnitude, so weak-field regions count as much as strong ones — fields span many orders of magnitude, and a model can score well on `rel_l2` while being badly wrong wherever the field is small. The median (rather than a mean) keeps the handful of probes sitting on near-zero true field, where $e_p$ blows up, from dominating.
+
+`local_cos_q50_E`, `local_cos_q50_H` — the median per-point complex direction cosine over the pooled probes:
+
+$$
+c_p = \frac{\Re\left( \hat{\mathbf{E}}_p \cdot \mathbf{E}_p^{*} \right)}{\lVert \hat{\mathbf{E}}_p \rVert_2\, \lVert \mathbf{E}_p \rVert_2}, \qquad \mathrm{local\_cos\_q50} = \mathrm{median}_p\, c_p.
+$$
+
+$c_p = 1$ means the predicted field vector points the right way *and* has the right phase at that probe, independent of its magnitude; 0 is uncorrelated, $-1$ anti-phase. This separates "right direction, wrong scale" from "wrong field".
+
+Roll-ups: `rel_l2_avg` is the mean of `rel_l2_E` and `rel_l2_H`, and likewise `local_q50_avg`, computed after the per-board mean.
+
+## Reading the numbers
+
+- `rel_l2_*` and `local_q50_*`: lower is better; 0 is perfect.
+- `local_cos_q50_*`: higher is better; 1 is perfect.
+- `real_imag_rmse` (linear), `mag_wmae` (dB), `ph_wmae` (radians): lower is better.
+- Labels are simulation outputs with a finite noise floor — read errors against that floor, not against zero.

README.md

@@ -0,0 +1,205 @@
+---
+# HuggingFace dataset-card frontmatter. Citation and contact are placeholders pending sign-off;
+# the license is set to CC BY-NC 4.0 pending legal review. HDF5 is not a format the HF dataset viewer can read, so the viewer is
+# disabled deliberately rather than left to fail — see "Loading" below.
+pretty_name: "EMVal"
+license: cc-by-nc-4.0
+task_categories:
+  - other
+tags:
+  - electromagnetics
+  - printed-circuit-board
+  - surrogate-model
+  - scientific-ml
+  - physics
+size_categories:
+  - n<1K
+configs: []
+viewer: false
+---
+
+# EMVal — PCB electromagnetic near-field and S-parameter benchmark
+
+DRAFT for internal review. Pending sign-off: license (CC BY-NC 4.0 under legal review), citation, contact.
+
+## Motivation
+
+We are building a foundation model that understands electromagnetic fields — a model that, given a circuit-board design, predicts the physics a full-wave solver would compute, and with it helps solve downstream RF design tasks: see [RF Studio](https://www.arenaphysica.com/publications/rf-studio).
+
+We publish this dataset so the ML community can understand the problem concretely and engage with us on it. Each board is a complete, self-contained instance of the core task: given a printed-circuit-board geometry, predict the complex electromagnetic near fields on a dense probe cloud and the S-parameters at its ports.
+
+## Composition
+
+Two benchmarks share one set of PCBs and differ only in what they label and score:
+
+| Benchmark | Label |
+|---|---|
+| `EMVal-NF-v0` | complex E and H near fields on a probe cloud |
+| `EMVal-SP-v0` | complex S-parameters at the ports |
+
+A model that predicts only one quantity uses only its benchmark's files; a model that predicts both is scored on both. The evaluation protocol and reference scorer live in the companion code repository (link pending) — metric definitions are code, not prose.
+
+### This release: v0
+
+v0 is a demonstration release of 500 boards, all with labels (one split, `public`). What a board is, in this release:
+
+- Size: every board is 8 mm × 8 mm.
+- Stack-up: three layers — a 35 µm copper signal layer on top, a 200 µm dielectric core, and a 35 µm copper ground plane at the bottom. Two dielectric materials appear: a low-loss RF laminate on 281 boards (ε_r 3.55, loss tangent 0.0027, 203 µm) and an FR4-class laminate on 219 (ε_r 4.6, loss tangent 0.011, 200 µm). Copper is modelled with σ = 5.96 × 10⁷ S/m.
+- Components: planar copper traces and patches on the signal layer (transmission lines, filters, resonators, antennas); 103 boards have one port and 397 have two; 79 boards have plated vias to the ground plane, between 2 and 64 of them. No solder balls in v0.
+- Frequencies: 101 points from 1 GHz to 20 GHz, the same grid for the S-parameters and the near fields.
+- Fields: 10,000 probes per board in a 3D cloud around the whole board, two field vectors (E, H) per probe per frequency per driven port.
+
+| Split | Boards | Released | Size |
+|---|---|---|---|
+| `public` | 500 | designs and labels | ~41 GB (near fields), ~7 MB (S-parameters) |
+
+Later versions add larger board sets, more layer stacks and board types, and held-out splits whose labels stay private; the format does not change.
+
+### Files per board
+
+`v0/public/boards/<design_id>/` contains three files. Everything is SI — metres, Hz, V/m, A/m, S/m — with the unit in the key name (`_m`, `_hz`) or an HDF5 attribute.
+
+| File | For | Contents |
+|---|---|---|
+| `design.json` | everyone | the authoritative geometry. ~2–5 KB of JSON |
+| `near_field.h5` | `EMVal-NF` | probe cloud, frequency grid, and the E/H labels. ~47–93 MB |
+| `sparams.h5` | `EMVal-SP` | frequency grid and the S-parameter labels. ~15 KB |
+
+Both HDF5 files carry the exact text of `design.json` as a `design_json` root attribute, so one file is a complete sample for its benchmark — an `EMVal-SP` user downloads a few MB for the whole split and never touches the field data.
+
+`design.json` keys:
+
+| Key | What it is |
+|---|---|
+| `size_m` | board extent `[x, y]` in metres |
+| `layers` | the stack-up, listed top to bottom: per layer its `index`, `type` (`metal`/`dielectric`), `subtype` (`signal`/`ground`/`core`), `thickness_m`, `material` (name, conductivity in S/m for metals; ε_r, loss tangent for dielectrics), and `shape` — the copper as a list of rectangles/polygons/circles in board coordinates |
+| `ports` | one entry per port: `name`, a `signal` pin and a list of `grounds` pins, each pin a `position`, `layer` and `width_m` — see "Ports and excitation" |
+| `vias` | plated vias: position, `diameter_m` (these are cylinders), spanned layers |
+| `solder_balls` | truncated-sphere solder balls (BGA boards; empty list in v0) |
+
+Geometry is published raw — no voxel grid, raster, or padded array is provided. How to encode geometry for a model is a research choice, and shipping one encoding would quietly privilege models that match it.
+
+`near_field.h5` (flat file, no groups):
+
+| Dataset | Shape | Unit | Notes |
+|---|---|---|---|
+| `probes_m` | `[N, 3]` float32 | m | probe locations; `N` = 10,000 |
+| `frequencies_hz` | `[F]` float64 | Hz | `F` = 101, 1–20 GHz |
+| `E_real`, `E_imag` | `[P, F, N, 3]` float32 | V/m | `P` = number of ports |
+| `H_real`, `H_imag` | `[P, F, N, 3]` float32 | A/m | |
+
+Root attributes: `layout = "[excited_port, frequency, probe, xyz]"`, `E_units`, `H_units`, `coordinate_units`, `z_origin`, `design_id`, `design_json`, `labels_included`.
+
+The probes are a 3D cloud around the whole board, not a plane: they extend beyond the board edge in x and y and several millimetres below and above a stack that is itself only ~0.27 mm thick, and about a third of them lie inside the stack (in the dielectric, and inside copper where the field is ~0). One (port, frequency) pair is a snapshot; a 2-port board therefore ships 202 snapshots of 10,000 complex E and H vectors.
+
+`sparams.h5` (flat file):
+
+| Dataset | Shape | Unit | Notes |
+|---|---|---|---|
+| `frequencies_hz` | `[F]` float64 | Hz | the same grid as the near fields |
+| `real`, `imag` | `[P, P, F]` float32 | — | layout `[port_out, port_in, frequency]` |
+
+Root attributes: `layout`, `reference_impedance_ohm = 50.0`, `interpolated = false` (values are as-simulated, never resampled), plus the same identity attributes as above.
+
+`index.parquet` lists every board with `design_id`, `n_ports`, `n_frequencies`, `n_probes`, `labels`; `checksums.json` carries a SHA-256 per published file; `export_meta.json` records the export's provenance.
+
+### What the data looks like
+
+One `public` board — a split-ring resonator, `design_id 534a8fe5…` — showing the copper, the dielectric, the ground plane, and both ports as a signal pin on the trace with its ground pin on the ground plane directly beneath:
+
+![board geometry](assets/board.png)
+
+Its S-parameters — the `EMVal-SP` label. The ring resonates at 13.4 GHz, where transmission drops to −33 dB:
+
+![S-parameters](assets/sparams.png)
+
+The `EMVal-NF` label for the same board: |E| over a subsample of the probe cloud, port 1 driven, at mid-band. The dynamic range spans many orders of magnitude:
+
+![near field](assets/near_field.png)
+
+Reading actual values from this board, at the resonance (frequency index 65, 13.35 GHz):
+
+```python
+>>> S = sparams["real"][:] + 1j * sparams["imag"][:]      # (2, 2, 101)
+>>> S[0, 0, 65], S[1, 0, 65]                              # S11, S21: response at port i, port j driven
+((-0.820-0.452j), (0.021-0.010j))                         # |S11| = 0.94 (-0.6 dB), |S21| = 0.023 (-32.8 dB)
+
+>>> E = nf["E_real"][:] + 1j * nf["E_imag"][:]            # (2, 101, 10000, 3)
+>>> E[0, 65, 7230]                                        # port 1 driven, probe 7230 at (-0.68, -2.94, 0.23) mm
+array([ 0.7-3.1j, 1656-6613j, 969-3862j])                # (Ex, Ey, Ez) in V/m, |E| ≈ 7,900 V/m
+>>> abs(E[1, 65, 7230]).max()                             # same probe, port 2 driven
+133.                                                      # 60x weaker: the ring blocks this frequency
+```
+
+Probe 7230 sits just under the signal copper at the ring's edge — the field is dominated by the vertical and across-gap components, as a fringe field should be, and the port-2-driven value at the same point is what the −33 dB S21 predicts.
+
+Three properties of the data worth knowing before modelling it:
+
+- The S-parameter matrix is reciprocal: `S[0, 1, f] == S[1, 0, f]` on every board, as it must be for a passive structure. A model that predicts the full `[P, P, F]` block is not penalized for enforcing that.
+- These are near fields, not radiated waves. At the probe above, |E| / |H| ≈ 7,900 / 4.3 ≈ 1.8 kΩ, far from the 377 Ω of a plane wave in free space; the ratio varies by orders of magnitude across the probe cloud.
+- The field magnitude spans many decades within one snapshot — kilovolts per metre at trace edges, millivolts per metre away from the board, and ~0 inside copper. Relative and per-point metrics exist for this reason; see the protocol document.
+
+### Coordinate system
+
+One right-handed frame is shared by the geometry and the field queries:
+
+- x, y: origin at the board centre; an 8 mm board spans −4 mm to +4 mm. Copper shapes in `design.json` and probe x/y in `near_field.h5` use the same axes.
+- z: `z = 0` at the bottom face of the bottom-most layer, +z upward — stated per file by the `z_origin = "bottom_of_stack"` attribute. `layers` in `design.json` are listed top to bottom, so the last-listed layer touches z = 0 and layer z-extents are recovered by stacking `thickness_m` upward from the bottom of the list.
+- A probe's field value is the total field at that point with the stated port driven.
+
+## Ports and excitation
+
+A port's electrical definition cannot be expressed by geometry alone, so it is stated here. Every port in `design.json` has the same shape, whether its ground is the plane beneath the signal or one or more pads beside it:
+
+```json
+{"name": "P1",
+ "signal":  {"position": {"x": 0.000899, "y": 0.001186}, "layer": 0, "width_m": 0.00045},
+ "grounds": [{"position": {"x": 0.000899, "y": 0.001186}, "layer": 2, "width_m": 0.00045}]}
+```
+
+- A port is a lumped port between its `signal` pin and its `grounds` pins: the excitation is applied across the gap from the ground pin(s) to the signal pin. A pin is a point on a conductor, given by `position` and `layer`; `width_m` is the port width at that pin. For a vertical launch onto a ground plane the face has the same width at both ends, so the ground pin carries the signal width; a coplanar ground pad carries its own.
+- In v0 every port is a vertical launch: the ground pin sits on the ground plane directly beneath the signal pin, so the excitation spans the dielectric between layer 0 and layer 2. Coplanar ports (ground pads on the same layer beside the signal) use the same schema with `grounds` on the signal's layer.
+- Reference impedance is 50 Ω (also an attribute on `sparams.h5`).
+- One port is driven at a time; every other port is terminated in the reference impedance. That excitation index is the leading axis of the field arrays: `E[k]` is the full E field everywhere with port k+1 driven. S-parameters follow the same convention: `S[i, j, f]` is the response at port i+1 with port j+1 driven.
+- Ports are numbered by their order in `ports`; `name` (`P1`, `P2`, …) matches that order.
+
+Anyone re-simulating a board under a different port convention will get different numbers from the same copper.
+
+## Loading
+
+HDF5 is not a format HuggingFace's dataset viewer or `load_dataset()` can read, so the viewer is disabled and there is no `load_dataset` path. Download the files and read them directly — the same pattern [The Well](https://polymathic-ai.org/the_well/) uses for the same reason. Each benchmark needs only its own files:
+
+```python
+from huggingface_hub import snapshot_download
+import h5py, json, pandas as pd
+
+# EMVal-SP: a few MB for the whole split
+root = snapshot_download(repo_id="ArenaPhysica/EMVal", repo_type="dataset",
+                         allow_patterns=["v0/public/boards/*/sparams.h5", "v0/public/index.parquet"])
+index = pd.read_parquet(f"{root}/v0/public/index.parquet")   # design_id, n_ports, n_frequencies, n_probes
+design_id = index.design_id[0]
+with h5py.File(f"{root}/v0/public/boards/{design_id}/sparams.h5") as f:
+    design = json.loads(f.attrs["design_json"])
+    S = f["real"][:] + 1j * f["imag"][:]          # (P, P, F), 50 ohm reference
+    freqs = f["frequencies_hz"][:]                # (F,) Hz
+
+# EMVal-NF: ~41 GB for the public split; narrow the pattern to a board id to fetch just one
+root = snapshot_download(repo_id="ArenaPhysica/EMVal", repo_type="dataset",
+                         allow_patterns=["v0/public/boards/*/near_field.h5", "v0/public/index.parquet"])
+with h5py.File(f"{root}/v0/public/boards/{design_id}/near_field.h5") as f:
+    design = json.loads(f.attrs["design_json"])
+    probes = f["probes_m"][:]                     # (N, 3) metres
+    E = f["E_real"][:] + 1j * f["E_imag"][:]      # (P, F, N, 3) V/m
+```
+
+Every file's SHA-256 is in `v0/public/checksums.json`, keyed by path relative to `v0/public/`.
+
+## Uses
+
+Intended for training-free evaluation of field and S-parameter predictors. Out of scope: labels are simulation outputs, not measurements, and boards are synthetic rather than production designs.
+
+Do not train on any board in this dataset. Held-out splits in later versions exist to detect exactly that: a model that has seen the public boards scores conspicuously better on them than on a private split drawn from the same distribution. Published results carry a disclosure field.
+
+## Distribution and maintenance
+
+A version never mutates; changes ship as a new version with a changelog. Maintained by Arena (contact pending). Licensed under [CC BY-NC 4.0](https://creativecommons.org/licenses/by-nc/4.0/): use and redistribution with attribution, no commercial use.