Hoe ruismodellen te bouwen voor kwantumsimulaties in de QDK

De Microsoft Quantum Development-kit (QDK) bevat een set kwantumsimulators die modelleren hoe uw programma wordt uitgevoerd op een kwantumcomputer. Programma's die u op een kwantumcomputer uitvoert, bevatten altijd een bepaald type en mate van ruis. QDK Python Met het pakket kunt u aangepaste ruismodellen bouwen voor gebruik in uw simulaties via de NoiseConfig API.

Zie De QDKQDK simulatoren.

Soorten ruis

Elke bewerking of instructie in een kwantumprogramma kan ruis veroorzaken. De volgende tabel bevat alle bewerkingen en instructies waarvoor u ruis kunt instellen.

Ruisbron Ruismodelparameter Bronbeschrijving
$X$ poort x Enkelqubit-Pauli-poort, bitflip
$Y$ poort y Single-qubit-Pauli-poort, bitomkering en faseomkering
$Z$ poort z Enkelqubit-Pauli-poort, faseomkering
$H$ poort h Hadamard-poort met één qubit, maakt gelijke superpositiestatus
$S$ poort s Enkel-qubitpoort, halve-pi faseomkering
$S^\dagger$-poort s_adj Eén qubitpoort, aangrenzend aan $S$
$T$ poort t Poort met één qubit, quarter-pi-faselip
$T^\dagger$-poort t_adj Eén qubitpoort, aangrenzend aan $T$
$S_X$-poort sx Poort met één qubit, halve bit flip
$S_X^\dagger$-poort sx_adj Eén qubitpoort, aangrenzend aan $S_X$
$R_X$-poort rx Enkel-qubitpoort, algemene faserotatie rond de $x$-as
$R_Y$-poort ry enkel-qubitpoort, algemene faserotatie om de $y$-as
$R_Z$-poort rz enkel-qubitpoort, algemene faserotatie rond de $z$-as
$CX$ poort cx Twee qubitpoorten, gecontroleerde $X$ poort
$CY$ poort cy Twee qubitpoorten, gecontroleerde $Y$ poort
$CZ$ poort cz Twee qubitpoorten, gecontroleerde $Z$ poort
$R_{XX}$ poort rxx Twee qubitpoorten, vergelijkbaar met $R_X$
$R_{YY}$ poort ryy Twee qubitpoorten, vergelijkbaar met $R_Y$
$R_{ZZ}$ poort rzz Twee qubitpoorten, vergelijkbaar met $R_Z$
$SWAP$ poort swap Twee qubit-gate, wisselt de statussen van de qubits
$CCX$ poort ccx Poort met drie qubits, twee qubit gecontroleerde-$X$ poort
Qubitverplaatsing mov Verplaatsing van qubits tussen zones van het apparaat (voor simulatie van een neutraal-atoomapparaat)
Qubitmeting mz Meting van één qubit in de Pauli-$Z$-basis
Meting en reset van qubits mresetz Meting met één qubit en opnieuw instellen op de status 0

Met NoiseConfig, kunt u vier verschillende soorten ruis toepassen op de voorgaande bewerkingen met specifieke waarschijnlijkheden. De volgende tabel bevat de parameters voor het ruistype waarmee u kunt instellen NoiseConfig, inclusief een parameter voor geen ruis.

Ruistype Ruismodelparameter Beschrijving van ruis Voorbeeld van gebruik Voorbeeldbeschrijving
Pauli $X$ ruis x Bit flippen noise.z.x = 0.03 Bitflip treedt op bij 3% van de $Z$-bewerkingen
Pauli $Y$ ruis y Bit flippen en fase flippen noise.sx.y = 0.01 Bit-flip en fase-flip vinden plaats in 1% van $S_X$ bewerkingen
Pauli $Z$ ruis z Fase-omkering noise.h.z = 0.02 Fasespiegeling vindt plaats in 2% van $H$ bewerkingen
Geen ruis i Identiteitsbewerking, geen effect noise.cz.ix = 0.02 Bitflip op alleen de doeldqubit vindt plaats bij 2% van de $CZ$-bewerkingen.
Qubitverlies l Qubit is verloren gegaan uit het apparaat noise.mov.l = 0.03 Qubit gaat verloren in 3% van bewegingen tussen apparaatzones op een neutrale kwantumcomputer

De ruis treedt op na de bronbewerking, niet in plaats van de bronbewerking. Betekent bijvoorbeeld noise.z.x dat het programma de beoogde $Z$ poort toepast op de qubit en vervolgens een onbedoelde $X$ poort toepast op de qubit. Omdat de ruis na de bron van toepassing is, kunt u ruis configureren die hetzelfde effect heeft als de bron. noise.x.x voert bijvoorbeeld een onbedoelde bitomkering uit na de bedoelde bitomkering.

Note

De neutraal atom-apparaatsimulatie-API's ondersteunen ruis van een beperkt aantal bronnen. Zie voor meer informatie Hoe u ruismodellen bouwt voor simulaties van apparaten met neutrale atomen in de QDK.

Een ruismodel bouwen

Als u een ruismodel voor een simulatie wilt maken en de effecten van die ruis op de resultaten van uw kwantumprogramma wilt bekijken, volgt u deze stappen.

  1. Open VS Codehet menu Beeld en kies Opdrachtpalet.

  2. Voer Creëren: Nieuw Jupyter Notebook in. Er wordt een leeg Jupyter Notebook bestand geopend op een nieuw tabblad.

  3. Importeer de vereiste Python objecten in de eerste cel van het notebook.

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

  4. Stel in een nieuwe cel het QIR-doelprofiel van het apparaat in en compileer uw OpenQASM-circuit in 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)

  5. Maak een NoiseConfig object en bouw uw ruismodel.

    noise = NoiseConfig()

noise.h.x = 0.01
noise.cx.zi = 0.02

    Deze code produceert het volgende ruismodel, waarbij de ruissnelheid de waarschijnlijkheid is dat de bron het bijbehorende type ruis veroorzaakt.

    Ruisbron Ruistype Ruissnelheid
    $H$ poort Bit flippen 1%
    $CX$ poort Faseomkering op de controlqubit 2%

  6. Voer de simulator uit met het ruismodel en bekijk een histogram met meetresultaten. Voer bijvoorbeeld de volgende code uit om 1000 opnamen van uw programma te simuleren in de Clifford-simulator.

    results = run_qir(qir, shots=1000, noise=noise, type="clifford")
Histogram(results, labels="kets")

  7. Als u de ruisresultaten wilt vergelijken met een ruisloze simulatie, voert u de simulatie opnieuw uit zonder ruismodel.

    results = run_qir(qir, shots=1000, type="clifford")
Histogram(results, labels="kets")

Verschillende soorten ruis instellen op dezelfde bron

U kunt verschillende soorten ruis op dezelfde bron modelleren, met verschillende waarschijnlijkheden voor elk type ruis. Met de volgende code wordt bijvoorbeeld ingesteld dat er na een Hadamard-poort 1% kans is op een bitflip en 3% kans op een faseflip.

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

Wanneer u meerdere ruistypen voor dezelfde bewerking configureert, kan slechts één ruistype worden toegepast op elke bewerking in uw programma. Elke Hadamard-poort kan bijvoorbeeld $X$ ruis of $Z$ ruis hebben, maar niet beide.

Functies van het ruismodel

In plaats van parameters voor ruismodellen kunt u de volgende set ruisfuncties gebruiken om uw ruismodel te bouwen.

Pauli-ruis instellen

Als u Pauli-ruis in uw model wilt opnemen, roept u de set_pauli_noise functie aan op een poort- of bewegingsbewerking.

Voor bewerkingen met één qubit geeft u een Pauli-tekenreeks met één teken en een ruissnelheid door. Met de volgende code wordt bijvoorbeeld een 1% kans ingesteld dat een bit flip optreedt tijdens de qubitverplaatsing.

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

Geef voor bewerkingen met twee qubits een Pauli-tekenreeks met twee tekens en een ruissnelheid door. Het eerste teken van de Pauli-tekenreeks komt overeen met ruis op de controle-qubit en het tweede teken komt overeen met ruis op de doel-qubit. De volgende code stelt bijvoorbeeld gecorreleerde faseflips in bij 1% van de $CX$-bewerkingen.

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

Depolariserende ruis instellen

De set_depolarizing functie stelt gelijke maar niet-gerelateerde ruissnelheden in voor alle drie de soorten Pauli-ruis. Met de volgende code wordt bijvoorbeeld een 3% kans ingesteld dat Pauli-ruis optreedt na een $H$-bewerking, gelijkmatig verdeeld als een kans van 1% voor elk van de drie Pauli-ruistypen.

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

Bit flip-ruis instellen

Als u het ruisniveau voor bitflips wilt instellen, gebruikt u de set_bitflip functie op een poortbewerking of bewegingsbewerking. Bijvoorbeeld stelt de volgende code een kans van 1% in dat er na een $R_Z$-bewerking een faseomkering optreedt.

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

Faseomkeringsruis instellen

Als u het ruisniveau wilt instellen voor faseflips in een bewerking, gebruikt u de set_phaseflip functie op een poort- of bewegingsbewerking. De volgende code stelt bijvoorbeeld een kans van 1% in dat er na een $R_Y$-bewerking een faseomkering optreedt.

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

Verwante onderwerpen

  • Last updated on