Andrew Peterson

An extensible platform for training, evaluating, and comparing classifiers — built so a new dataset drops in as a plugin without touching existing code.

How it works

Each dataset is a plugin that declares its models, preprocessing, and UI config. MNIST ships a CNN, a linear model and a hinge-loss SVM; Iris and BB84 ship a linear model, an SVM and a variational quantum circuit each, and PennyLane is an optional extra, so a lean install simply does not offer the quantum rows rather than failing at train time. Everything trains with live curves streamed over Server-Sent Events, and evaluates past a single accuracy number: per-class breakdowns, knowledge distillation, ensembles, and ablation studies.

Every number has to survive a test

The discipline is the point of the project. Each published accuracy is one seeded run scored on the full test split, and it ships with two error components, because one of them alone is misleading. The 95% Wilson interval covers sampling error. The spread across ten seeds covers the rest — and on Iris that spread is the larger of the two, wide enough that the published run turns out to be the best of its ten on two of the three rows. The artifact records every seed so the estimator can be changed after the fact, and a test holds every served document, every README table and the browser weights to it. A model nobody measured has to say so.

Negative results stay in. Distilling the MNIST CNN into the linear student costs about a point and is worse on all three seeds. Error mitigation on the hardware run made the divergence worse, not better. Nothing quantum here beats its classical baseline on any dataset, and the tables say so.

The paper’s quantum SVM, and what the hardware actually contributed

Yang et al.’s 2019 least-squares QSVM is rebuilt end to end and its decision rule ships to the browser as six numbers. Four are solved classically from the class means; the other two come from an HHL circuit run on ibm_marrakesh.

The interesting question is not how clean that run was but what it was worth. The rule decides by sign(v · w), so the measured alpha’s scale cancels and only the ratio of its two components reaches the boundary — one scalar, which came out 3.3% from its exact value. Alpha’s sign pattern is not measured at all, but taken from the ideal solution. Holding the map, orientation and split fixed and rebuilding the rule from the exact classical alpha tilts the boundary 1.58° and changes 19 of 1,530 held-out predictions: none of 30 on Iris, 4 of 500 on BB84, 15 of 1,000 on MNIST. The direction is inconsistent — MNIST is 1.5 points better under the hardware alpha, BB84 0.8 worse, each inside the other’s interval. So this is a small perturbation these splits cannot resolve, which is the honest reading in both directions.

Scored on held-out data the rule reaches 96.7% on Iris and 89.1% on MNIST 6-vs-9, against 100% and 91.6% for a logistic regression fitted to the same two features. A two-number quantum solution landing a few points under a classical linear model is what the paper expects, and it is what the measurement says.

The run also sat 0.0127 from ideal by Jensen–Shannon divergence against the paper’s 0.130 on IBMQX2 in 2019. That gap is seven years of IBM’s hardware rather than anything built here — the circuit transpiles to depth 18 against the paper’s logical depth 7 — so it is reported as context, not as a result.

It predicts in your browser

The exact preprocessing and softmax the server runs are ported client-side, on weights exported from the same models, and CI re-scores those committed weights on the real test splits so they cannot drift from the server. BB84 as a dataset — simulated key-distribution sessions, the video chat’s channel physics, classified as clean or eavesdropped from QBER and sifted-key rate — landed with zero changes to the serving tier. Being a simulator classifying a simulator, its accuracy is bounded by how the generator’s two regimes were set, which the model card says.

Stack

PyTorch · PennyLane for the variational classifiers and Qiskit for the QSVM recreation, both optional · Flask + Server-Sent Events · a dependency-free JavaScript frontend and UI kit. 439 test functions, 564 cases with parametrization, across model architectures, training loops, API routes, persistence and the published artifacts themselves.

The math, the derivations and the hardware run are in the QSVM paper recreation.

A web editor for resumes, CVs, and cover letters, backed by a normalized SQLite database as the single source of truth — content lives as structured records, not a blob of markup.

How it works

An Express REST API exposes 20+ endpoints with JSON Schema validation, reached through a Cloudflare Worker gateway with its own Google sign-in. The frontend is a Svelte 5 island:

• edit the document inline;
• save a variant — a reusable tag-rule lens over the same content, so one master yields many targeted CVs;
• reorder by drag or keyboard, restyle and re-layout live;
• track changes with checkpoint history and undo/redo.

Documents compile server-side through XeLaTeX (Awesome-CV) into a real PDF.

Demo-first by design

A live in-browser demo runs the real editor with no backend: it treats “not signed in” as the confident default and degrades gracefully instead of erroring. Any visitor can edit, reorder, tag and restyle a real document and export it as JSON. Compiling to a PDF and saving need an account, via Sign in with Google — and the demo edits you made come with you into your own profile.

What’s real

Driven by a deterministic, backend-mocked end-to-end suite plus unit tests across its logic tier — the slice controllers, variants, tags, and history.

Stack

Svelte 5 (runes) · Express · SQLite · Cloudflare Worker + Access · XeLaTeX · Playwright + Vitest.

Nonograms are picture-logic puzzles: fill a grid so every row and column matches its run-length clues. Underneath, that is a Boolean satisfiability problem — which makes it a clean testbed for the real question: where does a quantum computer actually help?

The result

Here, it does not. Every solvable board up to 4x4 was enumerated and deduplicated by clue pair — 62,535 puzzles — and scored against Grover’s round count. On 100% of single-solution boards from 3x3 upward, a backtracking solver’s worst board asks fewer questions than Grover needs rounds: 15 against 17 at 3x3, 56 against 201 at 4x4, and 246 against 4,549 on a 396,554-puzzle 5x5 sample. The gap widens with every size. The two units are reported separately rather than merged, since a placement is an upper bound on grid queries and a Grover round is exact.

Why the usual benchmark hides this

The standard oracle hands the clue formula to Qiskit’s PhaseOracleGate, which reduces it over all 2^n grids and emits one multi-controlled Z per solution. Constructing it means solving the puzzle first. Its cost is then a function of board size and solution count alone: across 30 distinct single-solution 4x4 boards it compiles to the same 227.5 two-qubit gates every time. Different puzzle, identical circuit. A benchmark resting on it reports the cost of Grover on an arbitrary n-bit function, not on the problem in its title.

So I built two oracles that do not hold the answer. One raises a flag qubit per line over that line’s legal patterns: 7x the answer-marking form at 3x3, and exponential in line width — 5,385 gates against 29,254 at the same 24 cells, on board shape alone. The second is a reversible run-length automaton that consults no solution at all, a verified prototype at 7-12x the answer-marking oracle for 2.1-3.3x the qubits, or 12-19x on the schedule that fits the device. Neither ratio means anything without its qubit cost beside it.

What ran on hardware

A 2x2 puzzle on ibm_torino resolved the correct state at 32.3% against 6.25% for chance — five times chance, against 47.3% for the same one-iteration circuit run noiselessly. A measured lift on a real device, not a textbook figure. Nothing larger fits: at 3x3 not one of the 17 required rounds survives a 200-layer coherence budget.

How it is checked

Every oracle is verified against the textbook amplification curve to 1e-9, so the comparison is between circuits that agree on which grids they mark; the automaton is additionally checked by exact reversible simulation over every basis input, asserting its scratch register returns to zero. The harness records every transpiler seed rather than the best one, which is what let a selection artifact in an early draft be caught. Rebuilding IBM’s own published Grover tutorial reproduces its circuit to within 0.5%.

Try it with nothing running

A classical solver runs entirely in your browser — draw or randomize a puzzle and it solves instantly, reporting real solve time and search-space size, with no backend awake. Quantum runs use the live solver; without it, a gallery of captured simulator runs shows real quantum output.

Stack

Python · Qiskit (Grover, statevector sampling, IBM Runtime) · Flask + Socket.IO · a dependency-free JavaScript frontend. Tests cover the Boolean encoding, solver correctness, oracle amplification, and hardware integration.

End-to-end encrypted, peer-to-peer video where the encryption keys are established through a simulated BB84 quantum key-distribution protocol rather than classical key exchange. Built during my research internship at Qualcomm Institute.

How it works

The full QKD pipeline runs client-side:

1. sifting — keep only the bits where the two parties’ bases matched;
2. error estimation — sample the quantum bit error rate (QBER);
3. Cascade error correction — reconcile the shared key over the public channel;
4. Toeplitz privacy amplification — hash out any information an eavesdropper could have gained.

The resulting key drives AES-128-GCM encryption of the WebRTC media streams via Insertable Streams.

The security property

The protocol carries its own tamper alarm: every frame whose QBER exceeds 7.3% is rejected, and an intercept-resend eavesdropper lands near 25%, so a tapped channel mints nothing at all.

7.3% rather than the textbook 11%, because those two numbers measure different things. 11% is where BB84’s own rate 1 − 2h(Q) reaches zero, and it charges error correction the Shannon bound. Cascade does not reach that bound — at the block sizes here it discloses about 1.65 times h(Q) — so this implementation runs out of key budget first. The gate is computed from the leakage model rather than quoted from the literature, and above it no pool of any size yields a key. Below it the cost is steep but payable: a clean channel mints from a few thousand pooled bits, 5% needs tens of thousands, and 7% needs millions.

What’s real

The simulated channel is not an error-free one: it models Poisson photon statistics, fiber loss, APD dark counts and polarization misalignment, which leaves an undisturbed link at about 1.5% QBER. That is the point of modelling it — a channel with no errors would skip the error correction and the privacy amplification that the error rate pays for, and produce keys along a path no physical link offers.

Unit, integration and browser suites cover the signaling server, the bench daemon and the client, and CI gates every merge on them. Media encryption is frame-level and SFrame-aligned (RFC 9605); a dropped connection recovers by ICE restart without surrendering the key, and a self-hosted TURN relay carries calls that cannot connect peer to peer.

Beyond the simulator, the same engine drives an optical bench: emulated instruments behind driver interfaces, a daemon per peer, and a fiber link between them — so the classical reconciliation path is exercised by hardware-shaped input, not only by a simulation.

Stack

Python signaling server and bench daemon · JavaScript client (BB84 simulation, WebRTC, Insertable Streams, Web Crypto AES-GCM).