Noise-Aware Testing of NISQ Quantum Programs: Self-Baseline Oracle with a Controlled False-Positive Rate
Dit artikel introduceert een ruisbewust testframework voor NISQ-kwantumprogramma's dat een zelf-baseline oracle met een gecontroleerde fout-positief-ratio gebruikt om fouten betrouwbaar van hardwareruis te onderscheiden, waarbij een significant hogere nauwkeurigheid en lagere fout-positieven worden bereikt dan bij methoden met een vaste drempelwaarde of globale kalibratie in zowel simulaties als experimenten op echte IBM-apparaten.
Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteur. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer
Quantumcomputers werken vandaag de dag in een luidruchtige, imperfecte wereld. In tegenstelling tot de klassieke machines die onze telefoons en laptops aandrijven, die informatie verwerken met absolute zekerheid, zijn deze nieuwe apparaten gebouwd van fragiele componenten die fouten maken. Elke keer dat een quantumcomputer een berekening uitvoert, is het resultaat niet één enkel, vaststaand antwoord, maar een wolk van mogelijkheden, licht vervormd door de hitte en trillingen van de hardware zelf. Deze ruis is zo significant dat een perfect geschreven programma telkens een ander resultaat kan produceren, wat het bijna onmogelijk maakt om te bepalen of een verandering in de output te wijt is aan een bug in de code of simpelweg aan de natuurlijke jitter van de machine. Voor software engineers die proberen betrouwbare applicaties op deze hardware te bouwen, creëert dit een fundamenteel probleem: hoe weet je of je programma correct werkt als de machine zelf onbetrouwbaar is?
Onderzoekers aan het National Institute of Technology Srinagar hebben een nieuwe manier ontwikkeld om deze quantumprogramma's te testen die deze ruis accepteert als een feit van het leven, in plaats van te proberen deze te elimineren. In plaats van de output van een programma te vergelijken met een perfect, theoretisch ideaal dat de hardware nooit werkelijk kan bereiken, vergelijkt hun methode het programma met zichzelf. Ze draaien een vertrouwde, bekende goede versie van de code vele malen op dezelfde machine om een basislijn vast te stellen van hoe "normale" ruis eruitziet. Vervolgens draaien ze het programma dat ze aan het testen zijn en controleren ze of de resultaten binnen het verwachte bereik van die basislijn vallen. Als de resultaten te ver afwijken, signaleert het systeem een potentiële fout. Deze aanpak stelt hen in staat om een precieze, vooraf bepaalde limiet in te stellen op hoe vaak ze een correct programma onterecht als kapot zullen beschuldigen, een niveau van controle dat eerdere methoden niet konden bereiken.
Het team testte dit framework uitgebreid door duizenden simulaties en echte experimenten uit te voeren op daadwerkelijke quantumhardware van IBM. Ze ontdekten dat hun nieuwe methode, die ze een noise-aware oracle noemen, succesvol houdt dat valse alarmen extreem zeldzaam blijven. In hun tests stelden ze als doel om een correct programma slechts één keer op elke duizend pogingen onterecht af te wijzen. Het systeem kwam deze belofte na en produceerde valse alarmen met een frequentie van slechts 0,0011, oftewel ongeveer één op duizend, over duizenden testruns heen. In schril contrast hiermee faalden oudere methoden die vertrouwen op vaste drempelwaarden — in feite het gokken op een afkappunt voor wat als een fout wordt beschouwd — jammerlijk. Die traditionele benaderingen wezen correcte programma's tussen de 36 procent en 74 procent van de tijd af, wat betekent dat ze een engineer zouden vertellen dat hun code kapot was terwijl deze eigenlijk prima was, vaker dan de helft van de tijd. Zelfs meer geavanceerde filters die ontworpen zijn om ruis wiskundig uit de resultaten te verwijderen, produceerden nog steeds valse alarmen in bijna 9 procent van de gevallen.
Naast het simpelweg opsporen van fouten, gebruikten de onderzoekers hun systeem ook om de aard van fouten in quantumcode te begrijpen. Ze creëerden duizenden licht gewijzigde versies van programma's, bekend als mutanten, om te zien hoe het systeem reageerde. Ze ontdekten dat een groot deel van deze wijzigingen, variërend van 24 procent tot 70 procent afhankelijk van het type toegevoegde gate, de gedragingen van het programma helemaal niet veranderde. Dit worden equivalente mutanten genoemd, en ze vormen een grote hoofdpijn voor het testen omdat ze tijd en middelen verspillen. Door een high-fidelity simulatie te gebruiken om elke mutant exact te labelen voordat deze op de ruisige hardware wordt gedraaid, konden de onderzoekers onderscheid maken tussen wijzigingen die er echt toe deden en die dat niet deden. Hun systeem identificeerde en verwierp correct 93,8 procent van de mutanten die de logica van het programma daadwerkelijk veranderden, terwijl de onschadelijke mutanten correct werden genegeerd. Deze precisie is essentieel omdat het ervoor zorgt dat wanneer een test faalt, het waarschijnlijk om een echt probleem gaat dat onderzoek waard is.
De onderzoekers pakten ook de moeilijke taak aan om te achterhalen waarom een test faalde. Wanneer het systeem een programma als kapot markeerde, moesten ze weten of de fout werd veroorzaakt door een bug in de software of door een tijdelijke piek in de ruis van de machine. Ze ontwikkelden een techniek waarbij het programma wordt gedraaid met de ruis kunstmatig versterkt, om vervolgens wiskundig te extrapoleren wat het resultaat zou zijn als de ruis zou worden verwijderd. Als het verschil tussen de programma's verdween wanneer de ruis werd verwijderd, was het een ruiseffect. Als het verschil bleef bestaan, was het een softwarebug. Deze methode werkte met hoge nauwkeurigheid bij lage en gemiddelde ruisniveaus, waarbij ze de oorzaak van de fout in 98 tot 99 procent van de gevallen van bugs en in 90 procent van de gevallen van ruis correct identificeerden. Ze ontdekten echter dat wanneer de ruis extreem hoog werd, de methode moeite kreeg, omdat het signaal te veel werd overstemd door de statische ruis om te kunnen scheiden.
Een cruciale bevinding van de studie was het belang van timing en consistentie. De onderzoekers ontdekten dat de ruis in deze machines niet statisch is; deze drijft in de loop van de tijd, en verandert van uur tot uur. Als een test wordt gekalibreerd in de ochtend en in de middag wordt uitgevoerd, kan de machine genoeg verschoven zijn om valse alarmen te triggeren. Om dit op te lossen, introduceerden ze een "sentinel" check, een snelle verificatierun die direct vóór een batch tests wordt uitgevoerd om te controleren of de machine niet is gedreven. Op een echte IBM quantum device verminderde deze eenvoudige controle het aantal valse positieven veroorzaakt door drift van 27,4 procent naar slechts 1,8 procent. Dit bewees dat voor quantumtesten betrouwbaar te zijn, het referentiepunt constant moet worden geverifieerd tegen de huidige staat van de machine.
De studie benadrukte ook de grenzen van hoeveel informatie er betrouwbaar uit deze machines kan worden geëxtraheerd. De nauwkeurigheid van de test hangt sterk af van het aantal keren dat het programma wordt gedraaid, bekend als shots. De onderzoekers ontdekten dat hun systeem alleen betrouwbaar werkt wanneer er ten minste 16 shots zijn voor elke mogelijke uitkomst die het programma kan produceren. Als het programma te complex is of het aantal runs te laag is, stort de statistische basis van de test in en wordt het percentage valse alarmen onvoorspelbaar. Dit stelt een praktische grens voor de huidige quantumtesten: naarmate programma's groter worden en meer mogelijke uitkomsten beslaan, moeten engineers ofwel de tests veel vaker uitvoeren, ofwel vereenvoudigde methoden gebruiken om slechts delen van het programma te controleren.
Uiteindelijk biedt dit werk een praktische toolkit voor het huidige tijdperk van quantumcomputing. Het beweegt het vakgebied weg van het onmogelijke doel om ruisige resultaten te vergelijken met een perfect, ruisloos ideaal, en naar een realistische standaard van het vergelijken van resultaten met een betrouwbare, ruisige basislijn. Door de ruis te accepteren en te meten, hebben de onderzoekers een testframework gecreëerd dat zowel gevoelig genoeg is om echte bugs te vangen als strikt genoeg is om niet vals alarm te slaan. Hun bevindingen suggereren dat met de juiste kalibratie en een constante controle op drift, software engineers kunnen beginnen de resultaten van quantumprogramma's te vertrouwen, wat de weg vrijmaakt voor complexere en betrouwbaardere applicaties in de toekomst. Het werk bevestigt dat hoewel de hardware imperfect is, de methoden om deze te testen rigoureus kunnen zijn, mits ze gebouwd zijn op de realiteit van de machine in plaats van op een ideaal dat niet bestaat.
Verdrinkt u in papers in uw vakgebied?
Ontvang dagelijkse digests van de nieuwste papers die bij uw onderzoekswoorden passen — met technische samenvattingen, in uw taal.