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 drie 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 eigen hardwarevertaling: eerst een 40-qubitpilot en daarna een opnieuw ontworpen 60-qubitroute met labelvrije genmodules. Beide circuits zijn werkelijk op IBM Fez uitgevoerd via Fire Opal.
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
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 |
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 een sterke praktische, partiële quantum-advantage-indicatie: betere held-out accuracy én veel snellere featuregeneratie dan onze poging om hetzelfde 60q-quantumcircuit klassiek te simuleren. Het is nog 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 onze ondiepe featuremap een hardwaregerichte benadering, 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 three 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 own hardware translation: first a 40-qubit pilot, then a redesigned 60-qubit route based on label-free gene modules. Both circuits were actually executed on IBM Fez through Fire Opal.
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 |
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.
This is a strong practical, partial quantum-advantage indication: higher held-out accuracy together with much faster feature generation than our attempt to classically simulate the same 60q quantum circuit. It 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. Our shallow feature map is also a hardware-oriented approximation rather than 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.