Översikt över kvantsimulatorer i QDK

Microsoft Quantum Development Kit (QDK) innehåller en uppsättning kvantsimulatorer som gör att du kan köra kvantprogram på den lokala datorn. Använd de lokala simulatorerna för att iterera i dina program innan du skickar dem för att köras på Azure Quantum mål.

Den QDK har fyra simulatorer:

  • Den glese simulatorn
  • Simulatorn Clifford
  • Simulatorn GPU
  • Simulatorn CPU

Den glese simulatorn

Den glesa simulatorn är standardsimulatorn i QDK. Den här simulatorn representerar kvantbitstillstånd som glesa vektorer för att dra nytta av gles matrisalgebra för snabba simuleringar, särskilt för program som inte genererar många superpositionstillstånd. Använd den glesa simulatorn när du vill ha snabba simuleringar av Q#, OpenQASMeller Qiskit program eller när du vill visa kvanttillståndet för ditt program under simuleringen.

Den glesa simulatorn är tillgänglig i både QDK tillägget för Visual Studio Code (VS Code) och QDKPython paketet. Den här simulatorn är den enda tillgängliga simulatorn i QDK tillägget, så kompilatorn anropar automatiskt den glesa simulatorn när du kör Q# och OpenQASM program i VS Code. Med den glesa simulatorn i VS Code kan du använda Q#DumpMachine funktionen eller felsökningsprogrammet för att visa qubittillståndsvektorer vid olika tidpunkter i simuleringen.

Både VS Code-tillägget och Python paketet stöder brusmodeller för glesa simuleringar av Q# och OpenQASM program. Endast paketet Python stöder gles simulering för Qiskit-program, men utan stöd för brusmodeller.

Mer information om den glesa simulatorn finns i Sparse-simulatorn.

Simulatorn Clifford

Simulatorn Clifford är snabb och effektiv för program med upp till tusentals kvantbitar, men kan bara simulera program som bara Clifford innehåller portar. Clifford portar är vanliga komponenter i felkorrigeringskretsar. Portuppsättningen Clifford består av portarna H, S och CX och alla portar som kan byggas från dessa tre portar. Följande Clifford portar är vanliga komponenter i kvantkretsar:

  • $X$, $Y$, och $Z$
  • $S$ och $S^\dagger$
  • $H$, eller Hadamard
  • $CX$, $CY$, och $CZ$
  • SWAP och iSWAP

Simulatorn Clifford är tillgänglig i QDKPython paketet för Q#, OpenQASM, Qiskitoch QIR program, men är inte tillgänglig i QDK tillägget för VS Code.

Simulatorn GPU

Simulatorn GPU är en fulltillståndssimulator som använder datorns GPU för att köra många bilder av kvantprogrammet parallellt. Den här simulatorn kan köra program som innehåller alla typer av portar, men som är dyra att köra. Simulatorn kan modellera upp till 27 kvantbitar. Kapaciteten hos datorns GPU avgör prestandan, men prestandan är optimal för program som har omkring 20 qubits och många körningar.

Simulatorn GPU tar QIR eller Qiskit som indata och är tillgänglig via vissa QDKPython paket-API:er, men inte VS Code-tillägget. Det finns också omfattande stöd för brusmodeller på alla typer av kvantgrindar eller operationer.

Simulatorn CPU

Liksom GPU-simulatorn är CPU-simulatorn en fullständigt tillståndssimulator som kan köra program som innehåller alla typer av kvantgrindar. Simulatorn är dock CPU långsammare eftersom den inte kan köra flera skott parallellt. Den här simulatorn skalar upp till cirka 25 kvantbitar, men saktar ned exponentiellt med fler kvantbitar på grund av minnesproblem. Använd CPU-simulatorn när datorn inte har en GPU, eller när programmet har få kvantbitar och du inte kör många körningar.

Simulatorn CPU tar QIR eller Qiskit som indata och är tillgänglig via vissa QDKPython paket-API:er, men inte VS Code-tillägget. Det finns också omfattande stöd för brusmodeller på alla typer av kvantgrindar eller operationer.

Vilken simulator ska jag använda?

Den bästa simulatorn som ska användas beror på flera faktorer, till exempel:

  • Din utvecklingsmiljö (VS Code eller Python)
  • Det kvantprogrammeringsramverk som du utvecklar i
  • Komplexiteten i ditt program och antalet bilder
  • Maskinvarufunktionerna för din lokala dator
  • Azure Quantum mål eller annan kvantmaskinvara som du vill köra dina program på
  • De brusmodeller som du vill skapa

I följande tabell sammanfattas de QDK alternativ och kvantprogrammeringsramverk som du kan använda för varje simulator:

Simulator Availability Ramverk som stöds
Sparsamt VS Code-tillägg och Python -paket Q#, OpenQASM, Qiskit
Clifford Python Paket Q#, OpenQASM, , QiskitQIR
GPU Python Paket Qiskit, QIR
CPU Python Paket Qiskit, QIR

Simuleringar i QDK tillägget för VS Code

Den glesa simulatorn är den enda tillgängliga simulatorn i QDK tillägget för VS Code. Om du vill använda den glesa simulatorn kör du din Q# eller OpenQASM filen i VS Code. Du kan lägga till begränsade brusmodeller i den glesa simulatorn för Q# program i VS Code, men inte för OpenQASM program.

Simuleringar i QDKPython paketet

Utvecklingsmiljön QDKPython stöder flera kvantramverk och alla fyra QDK simulatorer, men inte alla simulatorer är kompatibla med alla ramverk och API:er.

Den här tabellen visar de simulatorer som du kan använda för varje Python API som anropar en QDK simulator och det programmeringsramverk som varje API stöder:

Python API (applikationsprogrammeringsgränssnitt) Sparsamt Clifford GPU CPU Programmeringsramverk
qsharp.run ✅ ✅ Q#
openqasm.run ✅ ✅ OpenQASM
qiskit.QSharpBackend ✅ Qiskit
simulation.NeutralAtomDevice ✅ ✅ ✅ QIR
simulation.NeutralAtomBackend ✅ ✅ ✅ Qiskit
simulation.run_qir ✅ ✅ ✅ QIR

Relaterat innehåll

  • Last updated on