Fast and memory-efficient classical simulation of quantum machine learning via forward and backward gate fusion

Deze paper presenteert een methode voor het fuseren van quantumpoorten in zowel de voorwaartse als achterwaartse paden om de klassieke simulatie van quantum machine learning aanzienlijk te versnellen en geheugenefficiënter te maken, waardoor het trainen van grote modellen op consumer-GPU's mogelijk wordt.

De kern

De Kunst van het Quantum-Simuleren: Hoe we een 'Supercomputer' in je Videokaart proppen

Stel je voor dat je een recept wilt testen voor een heel speciale cake, maar je hebt geen echte oven. Je hebt alleen een gewone keuken. Je moet dan op papier uitrekenen hoe de cake zou worden als je die speciale oven had. Dit is wat wetenschappers doen met Quantum Machine Learning (QML). Ze proberen het gedrag van een quantumcomputer na te bootsen op een gewone computer, zodat ze nieuwe technologieën kunnen testen voordat de echte quantumcomputers klaar zijn.

Het probleem is echter: dit "rekenen op papier" is ontzettend zwaar. Het vraagt zoveel geheugen en tijd dat het vaak onmogelijk wordt om grote modellen te testen.

Dit onderzoek van Yoshiaki Kawase lost precies dat probleem op. Hier is hoe het werkt, vertaald naar een verhaal.

1. Het Probleem: De Overvolle Keuken

Stel je voor dat je een quantumcircuit ziet als een lange rij instructies in een keuken. Elke instructie is een "poort" (een gate).

• De oude manier: Je doet stap 1, schrijft het resultaat op een briefje, legt dat neer, doet stap 2, schrijft dat op een nieuw briefje, enzovoort.
• Het probleem: Als je 1000 stappen hebt, heb je 1000 briefjes nodig. Je keuken (het computergeheugen) raakt vol. Als je te veel briefjes hebt, moet je ze verplaatsen, wat tijd kost. Dit is wat de onderzoekers "geheugentoegang" noemen. Het is alsof je constant de koelkast in en uit loopt in plaats van alles op het aanrecht te hebben liggen.

2. De Oplossing: "Samenvoegen" (Gate Fusion)

De onderzoekers hebben een slimme truc bedacht die ze Gate Fusion noemen.

• De analogie: In plaats van dat je drie keer naar de koelkast loopt voor melk, suiker en bloem, pak je een dienblad en doe je alles in één keer.
• In de praktijk: In plaats van de computer te laten rekenen aan één quantum-poort per keer, bundelen ze er meerdere achter elkaar. Ze rekenen ze direct om tot één grote "super-poort".
• Het voordeel: De computer hoeft minder vaak data uit het geheugen te halen. Het is alsof je minder vaak hoeft te lopen in de keuken. Hierdoor gaat het 20 tot 30 keer sneller.

3. Het Leerproces: Voorwaarts en Achterwaarts

Om een AI te leren, moet je twee dingen doen:

1. Voorwaarts: De taart bakken (de berekening uitvoeren).
2. Achterwaarts: Kijken wat er misging om de volgende keer beter te doen (de 'gradiënt' berekenen).

Bij de oude methode moest je bij het 'Achterwaarts' kijken alle briefjes van de 'Voorwaarts' stap nog hebben liggen. Dat kostte veel ruimte.

• De nieuwe truc: Je slaat niet alle briefjes op. Je slaat alleen een paar 'checkpoints' op (belangrijke momenten). Als je tijdens het 'Achterwaarts' kijken een detail mist, rekent je het snel even opnieuw uit, maar dan wel slim: je gebruikt weer de "samenvoeging"-truc om dat snel te doen zonder je geheugen te vullen.

4. Het Resultaat: Van Supercomputer naar Videokaart

Dankzij deze methode kunnen ze nu enorme quantum-modellen simuleren op gewone videokaarten (zoals die in gaming-computers), in plaats van dat ze een dure supercomputer nodig hebben.

• Snelheid: Het is ongeveer 20 tot 30 keer sneller dan de standaard methoden.
• Geheugen: Ze kunnen een model trainen met 20 quantum-bits en 1000 lagen (een heel groot model) op een gewone computer.
• Tijd: Het trainen van zo'n groot model met duizenden voorbeelden kost nu ongeveer 20 uur, in plaats van dagen of weken.

Waarom is dit belangrijk?

Vroeger moesten onderzoekers wachten tot ze toegang kregen tot een supercomputer om quantum-AI te testen. Nu kunnen ze dat op hun eigen laptop of met een paar gewone servers doen. Dit versnelt de ontwikkeling van quantumtechnologie enorm. Het is alsof je van een fiets op een racefiets stapt: je komt veel sneller bij het doel, en je kunt nu ook op paden rijden die voorheen te zwaar waren.

Kortom: Ze hebben een manier gevonden om quantumrekenen op een gewone computer te "pakken" door minder onnodige stappen te zetten en slim te hergebruiken wat er al in het geheugen ligt. Hierdoor wordt Quantum Machine Learning voor iedereen toegankelijker.

Technische samenvatting

Hier is een gedetailleerde technische samenvatting van het artikel "Fast and memory-efficient classical simulation of quantum machine learning via forward and backward gate fusion" in het Nederlands.

Titel: Snelle en geheugenefficiënte klassieke simulatie van Quantum Machine Learning via forward en backward gate fusion

Auteur: Yoshiaki Kawase (Universiteit van Tokio)
Publicatie: Preprint (Elsevier/arXiv)

---

1. Het Probleem

Hoewel echte quantumapparaten steeds vaker worden gebruikt, blijven ze beperkt door ruis en connectiviteit (NISQ-technologie). Daarom is klassieke simulatie essentieel voor het onderzoek naar Quantum Machine Learning (QML) en Variational Quantum Algorithms (VQA's). Echter, klassieke simulatie van diepe quantumcircuits ondervindt ernstige uitdagingen:

• Geheugenkosten: Een state-vector simulatie vereist exponentieel veel geheugen ten opzichte van het aantal qubits.
• Gradiëntberekening: Het trainen van QML-modellen vereist het berekenen van gradiënten. De adjoint method is snel maar vereist normaal gesproken het opslaan van alle tussenliggende quantumtoestanden tijdens de forward pass, wat leidt tot een lineaire groei in geheugengebruik ($O(M \cdot 2^n)$).
• Bottleneck: Bestaande simulators zijn vaak geoptimaliseerd voor de forward path, maar de backward path (gradiënten) wordt geblokkeerd door inefficiënte toegang tot het geheugen (global memory bandwidth).
• Batch Processing: Veel bestaande simulators zijn niet ontworpen voor batch-verwerking, waardoor ze de parallelle prestaties van GPU's niet optimaal benutten.

2. Methodologie

De auteur stelt een nieuwe methode voor die gebruikmaakt van gate fusion (poortfusie) in zowel de forward als de backward paden, geïmplementeerd in Triton en PyTorch.

• Forward Path Gate Fusion:

  • Meerdere opeenvolgende single-qubit poorten worden samengevoegd tot één "fused operator".
  • In plaats van de state vector voor elke poort naar het globale geheugen te schrijven, wordt dit slechts één keer per gefuseerde groep gedaan.
  • Dit vermindert het aantal toegangspunten tot het globale geheugen aanzienlijk.

• Backward Path Gate Fusion (Kerninnovatie):

  • Voor het berekenen van gradiënten (adjoint methode) zijn de input-toestanden van de poorten nodig.
  • In plaats van alle tussenliggende toestanden op te slaan (wat veel geheugen kost), worden deze herberekend tijdens de backward pass.
  • De unitaire matrices worden dynamisch geladen wanneer nodig. Dit voorkomt dat registers vollopen (register spilling) en verlaagt de druk op het geheugen.
  • Hierdoor wordt de backward path even efficiënt gemaakt als de forward path qua geheugentoegang.

• Geheugenoptimalisatie:

  • Gradient Checkpointing: Combinatie met PyTorch's torch.utils.checkpoint om de geheugenschaal te reduceren van $O(d)$ naar $O(\sqrt{d})$ (waarbij $d$ het aantal lagen is).
  • Reduced Precision: In de "memory-saving mode" worden state vectors tijdelijk opgeslagen in lagere precisie (bfloat16) tijdens de forward pass, terwijl de berekeningen in hoge precisie (float32/64) blijven. Dit halveert het geheugengebruik voor opslag met minimale impact op nauwkeurigheid.

3. Belangrijkste Bijdragen

1. Bidirectionele Gate Fusion: De eerste implementatie die gate fusion effectief toepast op zowel de forward als de backward paden, wat de bottleneck van de backward pass wegneemt.
2. Integratie met PyTorch: De implementatie is naadloos geïntegreerd met het PyTorch-ecosysteem (inclusief automatische differentiatie), waardoor het eenvoudig te gebruiken is voor bestaande QML-workflows.
3. Scalabiliteit: Bewezen succesvolle simulatie van een 20-qubit model met 1.000 lagen (60.000 parameters), wat voorheen ondoenbaar was op consumer hardware zonder supercomputers.
4. Hardware-onafhankelijkheid: De methode werkt efficiënt op zowel datacenter GPU's (GH200) als mid-range consumer GPU's (RTX 5070/4090).

4. Resultaten

De prestaties zijn gemeten op verschillende GPU's (RTX 5070, RTX 4090, GH200) met een batchgrootte van 100 en 20 qubits:

• Doorvoer (Throughput):
  • 20x verbetering ten opzichte van de native PyTorch-implementatie voor circuits met 12 of meer qubits.
  • >30x verbetering op de mid-range RTX 5070 (beperkt geheugenbandbreedte), wat aantoont dat de methode zeer effectief is op hardware met geheugenbeperkingen.
• Geheugengebruik:
  • De piekgeheugengebruik blijft bijna constant ongeacht het aantal gefuseerde poorten, terwijl de native PyTorch-versie lineair toeneemt.
  • Door gradient checkpointing en reduced precision kan een 20-qubit, 1.000-lagen model worden getraind met een piekgeheugengebruik van ongeveer 95 GB.
• Trainingstijd:
  • Het trainen van 1.000 samples voor een 20-qubit model duurt ongeveer 20 minuten per epoch.
  • Dit betekent dat het trainen op grote datasets (zoals MNIST of CIFAR-10, tienduizenden samples) binnen een realistisch tijdsbestek (bijv. 20 uur per epoch) mogelijk is.
• Nauwkeurigheid:
  • De "memory-saving mode" (bfloat16 opslag) leidt slechts tot een 10% toename in rekentijd, maar verlaagt het geheugengebruik met 40%.

5. Betekenis en Impact

De voorgestelde methode verlaagt de drempel voor QML-onderzoek aanzienlijk:

• Toegankelijkheid: Onderzoekers kunnen diepe quantumcircuits en grote datasets trainen op single consumer GPU's, in plaats van afhankelijk te zijn van supercomputers of multi-GPU clusters.
• Onderzoek naar Lerende Theorieën: Het maakt het mogelijk om theorieën over deep quantum circuits te onderzoeken, zoals het bestaan van "barren plateaus" (vlakke gradiënten) en lokale minima, op grotere schaal dan voorheen mogelijk was.
• VQA Validatie: Het versnelt het valideren van variational quantum algorithms op grootschalige datasets, wat essentieel is voor het bewijzen van quantum utility.
• Toekomstige Toepassingen: De implementatie ondersteunt dubbele precisie (float64), wat het nuttig maakt voor theoretisch onderzoek zoals quantumchemie.

Conclusie: Door gate fusion te combineren met gradient checkpointing en geheugenreductietechnieken, heeft de auteur een klassieke simulator ontwikkeld die de doorvoer met een factor 20-30 verbetert en het geheugengebruik drastisch verlaagt, waardoor grootschalig QML-onderzoek op standaard hardware haalbaar wordt.