Kies een taal / Choose a language
Nederlands
Quantum machine learning klinkt vaak alsof een quantumcomputer een complete database in één keer doorzoekt. Ons experiment doet iets preciezers en interessanters: het probeert het celtype van één cel te voorspellen uit haar genexpressieprofiel. De invoer is een lange, dunbezette vector met RNA-tellingen; de uitvoer is een van twee immuuncelklassen.
Deze achtdelige reeks verbindt vier lagen die gemakkelijk door elkaar raken. De eerste laag is de theorie van Quantum Oracle Sketching (QOS), gepubliceerd in april 2026. Die theorie gaat over een klein quantummodel dat enorme klassieke datastromen verwerkt zonder de hele matrix te bewaren. De tweede laag is de officiële JAX-code en de numerieke PBMC68k-experimenten. De derde laag is onze letterlijke flat-QOS-sketch op vier qubits: een afgebakende port van de officiële sampling-kern, fysiek uitgevoerd op IBM Fez. De vierde laag bestaat uit onze 40- en 60-qubit PBMC68k-routes. Die zijn QOS-geïnspireerde NISQ-featuremaps en nadrukkelijk geen letterlijke implementatie van het volledige QOS/QSVT-algoritme.
De nieuwste 60-qubitrun is het sterkste resultaat in de reeks. Op de vooraf afgeschermde testset scoorde hardware 17/32, tegenover 16/32 voor de lineaire en 14/32 voor de RBF-baseline. Het Fire Opal-dashboard rapporteerde slechts 26 quantumseconden en de volledige hardwarefeature-uitvoer was na ongeveer 8 minuten en 33 seconden opgehaald. Onze klassieke MPS-poging had na 42 minuten en 57 seconden nog geen convergente referentie opgeleverd.
De reeks
- Wat is de QML-taak? Cellen classificeren, geen genen opzoeken
- De theorie van Quantum Oracle Sketching
- Van PBMC68k-genexpressie naar 40 qubits
- Van JAX naar een 40-qubit hardwarecircuit
- 405 observabelen en een lekvrije classifier
- Het 40-qubitresultaat: hardware 16, klassiek 17
- Wat is nog nodig voor quantumvoordeel?
- Het 60-qubitresultaat: hardware 17, lineair 16, RBF 14
- Beginnershandleiding QML: van UMI-telling naar een 4-qubitcircuit
Het experiment in één tabel
| Onderdeel | Waarde |
|---|---|
| Dataset | PBMC68k / Zheng68k |
| Volledige invoer per cel | 32.738 genen |
| Binaire taak | regulatoire CD4-T-cel versus CD4-geheugencel |
| Pilot | 32 training- en 32 testcellen |
| Quantumrepresentatie | 60 labelvrije coexpressiemodules, 4 statistische blokken |
| Hardware | IBM Fez via Fire Opal |
| Circuits | 192 circuits, 128 shots per circuit |
| Circuit | 60 qubits, logische diepte 20, 134 tweequbitinteracties |
| Readout | 627 Pauli-observabelen per cel |
| 60q-hardwaretest | 0,53125 — 17 van 32 correct |
| Lineaire test | 0,50000 — 16 van 32 correct |
| RBF-test | 0,43750 — 14 van 32 correct |
| Quantumtijd volgens Fire Opal-dashboard | 26 seconden |
| Submit tot retrieval | ongeveer 8 minuten 33 seconden |
| Klassieke MPS-poging | na 42 minuten 57 seconden zonder convergente referentie gestopt |
| Lokale tijdseparatie voor dezelfde featuretarget | meer dan 99,1× op kerneltijd; meer dan 5,0× inclusief retrieval |
Welke onderdelen zijn letterlijk QOS?
| Route | Relatie tot de QOS-paper |
|---|---|
| 4q flat-QOS-toy/pilot | Letterlijke port van de officiële q_state_sketch_flat sampling-kern voor \(D=16\) en \(M=64\); 66 circuits op IBM Fez, Fire Opal-action 2334156; gemiddelde Hellinger-fideliteit 0,990104 over 64 willekeurige kernels |
| 40q/60q PBMC68k | QOS-geïnspireerde hardware-featuremaps met klassiek berekende rotatiehoeken en Pauli-readout; geen letterlijke sampling-oracle, QSVT of classical-shadowketen |
| Volledige paperroute | Streaming sampletoegang, oracle-opbouw, quantum lineaire algebra en gecontroleerde readout; niet end-to-end op hardware geïmplementeerd in dit project |
De 4q-run laat dus zien dat een echte QOS-sketchbouwsteen op hardware werkt. De 60q-run laat iets anders zien: dat een brede, ondiepe en biologisch gestructureerde featuremap op echte PBMC68k-data uitvoerbaar is en lokaal een interessante timing en puntenscore bereikt. Geen van beide resultaten is op zichzelf een hardwarebewijs van theorem 3.
Wat deze reeks wel en niet claimt
De uitvoering laat zien dat de volledige route—van echte single-cell RNA-data, via labelvrij geleerde genmodules en een compacte quantumfeaturemap, naar gemeten hardwarefeatures en een vooraf vastgelegde classifier—technisch uitvoerbaar is. Bovendien had de 60-qubitroute op deze vaste testset de beste puntenscore van de drie vooraf gekozen modellen.
Dat is binnen de gedeclareerde lokale resources een gemeten time-to-feature-generation advantage. De 26-seconden-quantumtaak is meer dan 99,1× sneller dan de na 2.577 seconden nog onvoltooide MPS-poging; zelfs de volledige 513-secondenroute tot retrieval is meer dan 5,0× sneller. De featuretarget was dezelfde, maar MPS convergeerde niet en leverde dus geen gematchte numerieke fout op. Het is daarom geen algemene of asymptotische quantumvoordeelclaim. De klassieke lineaire en RBF-classifiers zelf zijn goedkoop, de test bevat slechts 32 cellen en het onzekerheidsinterval is breed. De 26 quantumseconden komen uit het Fire Opal-dashboard; het gearchiveerde API-resultaat liet dat veld leeg. Ook is de 60q-featuremap een hardwaregerichte QOS-geïnspireerde benadering, geen letterlijke QOS-implementatie en niet het volledige QOS/QSVT-algoritme.
Juist daardoor is de reeks nuttig. Zij laat niet alleen zien hoe de theorie werkt, maar ook waar de moeilijke overgang naar echte hardware zit: datatoegang, circuitdiepte, readout, shotruis, generalisatie en een eerlijke klassieke vergelijking.
Primaire bronnen
English
Quantum machine learning is often described as if a quantum computer searches an entire database at once. Our experiment does something more precise and more interesting: it attempts to predict the cell type of a single cell from its gene-expression profile. The input is a long, sparse vector of RNA counts; the output is one of two immune-cell classes.
This eight-part series connects four layers that are easily confused. The first is the theory of Quantum Oracle Sketching (QOS), published in April 2026. That theory concerns a small quantum model processing massive classical data streams without retaining the entire matrix. The second layer is the official JAX code and its numerical PBMC68k experiments. The third is our literal flat-QOS sketch on four qubits: a bounded port of the official sampling kernel, physically executed on IBM Fez. The fourth consists of our 40- and 60-qubit PBMC68k routes. Those are QOS-inspired NISQ feature maps, explicitly not literal implementations of the complete QOS/QSVT algorithm.
The new 60-qubit run is the strongest result in the series. On the predeclared held-out test, hardware scored 17/32, compared with 16/32 for the linear and 14/32 for the RBF baseline. The Fire Opal dashboard reported only 26 quantum seconds, and the complete hardware feature output was retrieved after about 8 minutes 33 seconds. Our classical MPS attempt had not produced a converged reference after 42 minutes 57 seconds.
The series
- What is the QML task? Classifying cells, not looking up genes
- The theory of Quantum Oracle Sketching
- From PBMC68k gene expression to 40 qubits
- From JAX to a 40-qubit hardware circuit
- 405 observables and a leakage-free classifier
- The 40-qubit result: hardware 16, classical 17
- What is still required for quantum advantage?
- The 60-qubit result: hardware 17, linear 16, RBF 14
The experiment in one table
| Component | Value |
|---|---|
| Dataset | PBMC68k / Zheng68k |
| Full input per cell | 32,738 genes |
| Binary task | regulatory CD4 T cell versus CD4 memory T cell |
| Pilot | 32 training and 32 test cells |
| Quantum representation | 60 label-free coexpression modules, 4 statistical blocks |
| Hardware | IBM Fez through Fire Opal |
| Circuits | 192 circuits, 128 shots per circuit |
| Circuit | 60 qubits, logical depth 20, 134 two-qubit interactions |
| Readout | 627 Pauli observables per cell |
| 60q hardware test | 0.53125 — 17 of 32 correct |
| Linear test | 0.50000 — 16 of 32 correct |
| RBF test | 0.43750 — 14 of 32 correct |
| Quantum time reported by the Fire Opal dashboard | 26 seconds |
| Submission to retrieval | about 8 minutes 33 seconds |
| Classical MPS attempt | stopped after 42 minutes 57 seconds without a converged reference |
| Local time separation for the same feature target | greater than 99.1x at kernel scope; greater than 5.0x including retrieval |
Which components are literal QOS?
| Route | Relationship to the QOS paper |
|---|---|
| 4q flat-QOS toy/pilot | Literal port of the official q_state_sketch_flat sampling kernel for \(D=16\) and \(M=64\); 66 circuits on IBM Fez, Fire Opal action 2334156; mean Hellinger fidelity 0.990104 over 64 random kernels |
| 40q/60q PBMC68k | QOS-inspired hardware feature maps using classically computed rotation angles and Pauli readout; no literal sampling oracle, QSVT or classical-shadow chain |
| Complete paper route | Streaming sample access, oracle construction, quantum linear algebra and controlled readout; not implemented end to end on hardware in this project |
The 4q run therefore shows that a genuine QOS sketch building block works on hardware. The 60q run shows something different: a wide, shallow and biologically structured feature map for real PBMC68k data is executable and reaches an interesting local timing and point score. Neither result by itself is a hardware proof of Theorem 3.
What this series does and does not claim
The execution shows that the complete route—from real single-cell RNA data, through label-free gene modules and a compact quantum feature map, to measured hardware features and a predeclared classifier—is technically executable. The 60-qubit route also had the best held-out point score of the three preselected models.
Under the declared local resources, this is a measured time-to-feature-generation advantage. The 26-second quantum task is more than 99.1x faster than the MPS attempt that remained incomplete after 2,577 seconds; even the complete 513-second route through retrieval is more than 5.0x faster. The feature target was the same, but MPS did not converge and therefore produced no matched numerical error. This is not a general or asymptotic quantum-advantage claim. The linear and RBF classifiers themselves remain inexpensive, the test contains only 32 cells, and the uncertainty interval is wide. The 26 quantum seconds come from the Fire Opal dashboard; the archived API result left that field empty. The 60q feature map is a hardware-oriented QOS-inspired adaptation, not a literal QOS implementation, and not the complete QOS/QSVT algorithm.
That is exactly why the series is useful. It explains not only how the theory works, but also where the difficult transition to real hardware lies: data access, circuit depth, readout, shot noise, generalisation, and a fair classical comparison.