Så här skapar du brusmodeller för kvantsimuleringar i QDK

Microsoft Quantum Development Kit (QDK) innehåller en uppsättning kvantsimulatorer som modellerar hur programmet körs på en kvantdator. Program som du kör på en kvantdator innehåller alltid någon typ och grad av brus. Med QDKPython paketet kan du skapa anpassade brusmodeller som ska användas i dina simuleringar via API:et NoiseConfig .

Anvisningar om hur du installerar och använder QDK simulatorerna finns i Installera och köra QDK kvantsimulatorerna.

Typer av brus

Varje åtgärd eller instruktion i ett kvantprogram kan introducera brus. I följande tabell visas alla åtgärder och instruktioner som du kan ange brus för.

Bruskälla	Brusmodellparameter	Källbeskrivning
$X$-port	`x`	Pauli-grind för enqubit, bitväxling
$Y$ grind	`y`	Enkelqubits-Pauli-grind, bitvändning och fasvändning
$Z$ grind	`z`	Pauli-port för en qubit, fasflip
$H$ grind	`h`	Hadamard-port för en enkel qubit, skapar ett likafördelat superpositionstillstånd
$S$ grind	`s`	Enkel qubitgrind, halv pi-fasvändning
$S^\dagger$ gate	`s_adj`	Enqubitsgrind, adjungaten till $S$
$T$-grind	`t`	Enkelqubitgrind, kvarts-pi-faslip
$T^\dagger$ gate	`t_adj`	En qubit-grind, angränsande till $T$
$S_X$ port	`sx`	En qubit-grind, halvvägs bitflip
$S_X^\dagger$ gate	`sx_adj`	Enqubitsgrind, adjungaten till $S_X$
$R_X$ grind	`rx`	En qubitsgrind, allmän fasrotation om $x$-axeln
$R_Y$-grind	`ry`	En qubitsgrind, allmän fasrotation om $y$-axel
$R_Z$-port	`rz`	Enkubitgrind, allmän fasrotation kring $z$-axeln
$CX$-port	`cx`	Två-qubit-gate, kontrollerad $X$-gate
$CY$-port	`cy`	tvåqubitgrind, kontrollerad-$Y$-grind
$CZ$ port	`cz`	Två-qubit grind, kontrollerad-$Z$ grind
$R_{XX}$-port	`rxx`	Tvåqubitsgrind, analog till $R_X$
$R_{YY}$-port	`ryy`	Tvåqubitsgrind, analog med $R_Y$
$R_{ZZ}$ grind	`rzz`	Två-qubit grind, analogt med $R_Z$
$SWAP$-grind	`swap`	Tvåqubitsgrind, byter plats på qubitarnas tillstånd
$CCX$-port	`ccx`	tre-qubit-grind, två-qubit-kontrollerad-$X$-grind
Qubit-rörelse	`mov`	Kvantbitsförflyttning mellan enhetszoner (för neutral atomenhetssimulering)
Kvantbitsmätning	`mz`	Mätning av en enskild qubit i Pauli-$Z$-basen
Kvantbitsmätning och återställning	`mresetz`	Mätning med en kvantbit och återställning till 0-tillstånd

Med NoiseConfigkan du tillämpa fyra olika typer av brus på föregående åtgärder med specifika sannolikheter. I följande tabell visas de brustypsparametrar som du kan ange med NoiseConfig, inklusive en parameter utan brus.

Typ av brus	Brusmodellparameter	Beskrivning av brus	Exempel på användning	Exempelbeskrivning
Pauli $X$-störning	`x`	bitvändning	`noise.z.x = 0.03`	En bitvändning inträffar i 3 % av $Z$-operationerna
Pauli $Y$ störning	`y`	Bitvändning och fasvändning	`noise.sx.y = 0.01`	Bitvändning och fasvändning sker i 1% av $S_X$-åtgärder
Pauli $Z$ störning	`z`	Fasvändning	`noise.h.z = 0.02`	Fasflip sker i 2 % av $H$-operationer
Inget brus	`i`	Identitetsåtgärd, ingen effekt	`noise.cz.ix = 0.02`	Bitflip på endast målkubit sker i 2% av $CZ$ operationer
Qubit-förlust	`l`	Qubit går förlorad från enheten	`noise.mov.l = 0.03`	En qubit går förlorad vid 3 % av förflyttningarna mellan enhetszoner i en kvantdator med neutrala atomer

Bruset inträffar efter källåtgärden, inte i stället för källåtgärden. Till exempel innebär noise.z.x att programmet tillämpar den avsedda $Z$-grinden på qubiten och sedan tillämpar en oavsiktlig $X$-grind på qubiten. Eftersom bruset gäller efter källan kan du konfigurera brus som har samma effekt som källan. Till exempel utför noise.x.x en oavsiktlig bitvändning efter den avsiktliga bitvändningen.

Anmärkning

API:er för simulering av neutrala atomenheter stöder brus från ett begränsat antal källor. Mer information finns i Skapa brusmodeller för neutrala atomenhetssimuleringar i QDK.

Skapa en brusmodell

Följ dessa steg för att skapa en brusmodell för en simulering och visa effekterna av bruset på resultatet av ditt kvantprogram.

I VS Codeöppnar du menyn Visa och väljer Kommandopalett.
Ange Skapa: Ny Jupyter Notebook. En tom Jupyter Notebook fil öppnas på en ny flik.

I den första cellen i notebook-filen importerar du de nödvändiga Python objekten.

from qdk import init, TargetProfile
from qdk.openqasm import compile
from qdk.simulation import NoiseConfig, run_qir
from qdk.widgets import Histogram

I en ny cell anger du QIR-målprofilen för enheten och kompilerar din OpenQASM-krets till QIR.

init(target_profile=TargetProfile.Base)

qasm_src = """
include "stdgates.inc";
qubit[2] qs;
bit[2] r;

h qs[0];
cx qs[0], qs[1];
r = measure qs;
"""

qir = compile(qasm_src)

Skapa ett NoiseConfig objekt och skapa din brusmodell.
```
noise = NoiseConfig()

noise.h.x = 0.01
noise.cx.zi = 0.02
```
Den här koden genererar följande brusmodell, där brusfrekvensen är sannolikheten att källan orsakar motsvarande typ av brus.

Bruskälla Typ av brus Brusfrekvens

$H$ grind bitvändning 1 %

$CX$-port Fasvändning av kontrollkvabit 2%
Kör simulatorn med brusmodellen och visa ett histogram med mätresultat. Kör till exempel följande kod för att simulera 1 000 bilder av ditt program på Clifford-simulatorn.
```
results = run_qir(qir, shots=1000, noise=noise, type="clifford")
Histogram(results, labels="kets")
```
Om du vill jämföra bullriga resultat med en brusfri simulering kör du simuleringen igen utan brusmodell.
```
results = run_qir(qir, shots=1000, type="clifford")
Histogram(results, labels="kets")
```

Bruskälla	Typ av brus	Brusfrekvens
$H$ grind	bitvändning	1 %
$CX$-port	Fasvändning av kontrollkvabit	2%

Ange flera typer av brus på samma källa

Du kan modellera olika typer av brus på samma källa, med olika sannolikheter för varje typ av brus. Följande kod anger till exempel en sannolikhet på 1 % för att en bitväxling inträffar och en sannolikhet på 3 % för att en fasväxling inträffar efter en Hadamard-gate.

noise.h.x = 0.01
noise.h.z = 0.03

När du konfigurerar flera brustyper för samma åtgärd kan endast en brustyp gälla för varje åtgärd i programmet. Till exempel kan varje Hadamard-grind ha antingen $X$ brus eller $Z$ brus, men inte båda.

Funktioner för brusmodell

I stället för brusmodellparametrar kan du använda följande uppsättning brusfunktioner för att skapa brusmodellen.

Ställ in Pauli-brus

Om du vill inkludera Pauli-brus i din modell anropar du set_pauli_noise funktionen på en grind- eller rörelseåtgärd.

För åtgärder med en kvantbit skickar du en Pauli-sträng med ett tecken och en brusfrekvens. Följande kod anger till exempel en 1% chans att en bit flip inträffar under kvantbitsförflyttning.

# Equivalent to: noise.mov.x = 0.01
noise.mov.set_pauli_noise('X', 0.01)

För tvåqubitsoperationer anger du en Pauli-sträng med två tecken och en brusnivå. Det första tecknet i Pauli-strängen motsvarar brus på kontrollkvabiten och det andra tecknet motsvarar brus på målkvabiten. Till exempel anger följande kod korrelerade fasvändningar för 1 % av $CX$-operationerna.

# Equivalent to: noise.cx.zz = 0.01
noise.cx.set_pauli_noise('ZZ', 0.01)

Ange avpolariserande brus

Funktionen set_depolarizing ställer in lika men okorrelerade brusfrekvenser för alla tre typerna av Pauli-brus. Följande kod anger till exempel en 3% chans att Pauli-brus inträffar efter en $H$ åtgärd, fördelat jämnt som en 1% chans för var och en av de tre Pauli-brustyperna.

# Equivalent to:
#     noise.h.x = 0.01
#     noise.h.y = 0.01
#     noise.h.z = 0.01
noise.h.set_depolarizing(0.03)

Ställ in bitflippbrus

Om du vill ange brushastigheten för bitvändningar använder du set_bitflip funktionen på en grind- eller rörelseåtgärd. Följande kod anger till exempel en 1% chans att en fasvändning inträffar efter en $R_Z$-åtgärd.

# Equivalent to: noise.rz.x = 0.01
noise.rz.set_bitflip(0.01)

Ställ in fasvändningsbrus

Om du vill ställa in brusfrekvensen för fasvändningar i en åtgärd använder du set_phaseflip funktionen på en grind- eller rörelseåtgärd. Följande kod anger till exempel en 1% chans att en fasvändning inträffar efter en $R_Y$-åtgärd.

# Equivalent to: noise.ry.z = 0.01
noise.ry.set_phaseflip(0.01)

Feedback

Var den här sidan till hjälp?

Last updated on 2026-08-18