Notatka
Dostęp do tej strony wymaga autoryzacji. Może spróbować zalogować się lub zmienić katalogi.
Dostęp do tej strony wymaga autoryzacji. Możesz spróbować zmienić katalogi.
Pakiet Microsoft Quantum Development Kit (QDK) Python obsługuje elastyczne modele szumów dla bram z wieloma kubitami w symulacjach programów kwantowych. Możesz modelować skorelowane błędy i inne efekty szumu w wielu kubitach, aby dokładniej reprezentować zachowanie sprzętu kwantowego.
Aby uzyskać więcej informacji o modelach szumów w programie QDK, zobacz Jak tworzyć modele szumów na potrzeby symulacji kwantowych w QDK.
Prerequisites
Aby tworzyć modele szumów w programie QDK, zainstaluj te narzędzia.
- Visual Studio Code (VS Code) z zainstalowanym QDK rozszerzeniem i Jupyter rozszerzeniem .
- Najnowsza wersja
qdkPython pakietu z dodatkiemjupyter.
pip install --upgrade "qdk[jupyter]"
Skorelowany szum
Bramy z wieloma kubitami mogą generować skorelowany szum, w którym ten sam wzorzec szumu ma zastosowanie do wszystkich kubitów, na których działa brama. Aby ustawić skorelowany szum na bramkach z wieloma kubitami, określ parametr szumu dla każdego kubitu.
Na przykład ten Python kod ustawia skorelowane przerzucanie bitów na bramach $CX$ z prawdopodobieństwem 2%. Gdy w bramce $CX$ wystąpi szum, bramkę $X$ stosuje się zarówno do kubitu sterującego, jak i do kubitu docelowego. Szum jest skorelowany, ponieważ szum zawsze ma zastosowanie do obu kubitów.
from qdk.simulation import NoiseConfig
noise = NoiseConfig()
noise.cx.xx = 0.02
Aby szum był nieskorelowany, ustaw wiele typów szumu za pomocą parametru identity.
noise.cx.xi = 0.02 # Bit flip on control qubit, do nothing to target qubit
noise.cx.ix = 0.02 # Do nothing to control qubit, bit flip on target qubit
W tym modelu każdy wpis szumu ma prawdopodobieństwo 2%. Ponieważ symulator próbkuje co najwyżej jeden skonfigurowany wpis szumu dla każdej operacji bramy, ten model nie może zastosować $X$ szumu do obu kubitów podczas tej samej operacji $CX$.
Aby modelować możliwość szumu w obu kubitach, skonfiguruj inne ustawienie szumu, które stosuje szum do obu kubitów.
noise.cx.xi = 0.02 # Bit flip on control qubit, do nothing to target qubit
noise.cx.ix = 0.02 # Do nothing to control qubit, bit flip on target qubit
noise.cx.xx = 0.02 # Bit flip on both qubits
Szum w rotacjach innych niż Clifford wielokubitowe
Symulator stabilizatora obsługuje dowolnokątne obroty $R_{XX}$, $R_{YY}$ i $R_{ZZ}$ poprzez rozgałęzianie stabilizatora. Szum skonfigurowany na rxx, ryy lub rzz jest stosowany po idealnej rotacji. To zachowanie nie zmienia się, jeśli rotacja tworzy dodatkowe gałęzie stabilizatora.
Każda rotacja inna niż Clifford może zwiększyć liczbę gałęzi, więc użycie pamięci i czas strzału mogą rosnąć wykładniczo. Użyj symulatora stabilizatora dla obwodów z ograniczoną liczbą obrotów nie-Clifford i użyj symulatora pełnego stanu procesora CPU lub procesora GPU, gdy operacje nie-Clifford stanowią znaczną część obwodu.
Zasady utraty kubitów
Utrata kubitów to rodzaj zakłócenia, w którym kubity są utracone z urządzenia. Zasady dotyczące utraty definiują zachowanie bramki wielokubitowej, gdy w chwili rozpoczęcia operacji brakuje jednego lub większej liczby kubitów. QDK obsługuje te zasady postępowania w przypadku utraty.
| Zasady dotyczące utraty | Bramy, których może dotyczyć zasada | Wpływ na pozostałe kubity |
|---|---|---|
SKIP |
Wszystkie bramy | Brama nie ma wpływu na pozostałe kubity |
PROPAGATE |
Wszystkie bramy | Pozostałe kubity również zostaną utracone |
DEGRADE |
rxx, ryyi rzz |
Zastosuj jako bramę z jednym kubitem do pozostałych kubitów |
RESIDUAL_S_DAGGER |
Wszystkie bramy | Zastosuj bramkę s_adj do pozostałych kubitów |
APPLY_ANYWAY |
swap |
Pozostały kubit nadal zamienia się stanami z utraconym kubitem |
Aby zasady obsługi utraty wpływały na symulację, uwzględnij utratę kubitów w modelu szumu. Symulacja śledzi utracone kubity. Reguły dotyczące utraty mają zastosowanie, gdy brama działa na co najmniej jednym utraconym kubicie.
Aby uwzględnić strategie strat w swoim modelu szumu, użyj polecenia LossPolicy z modułu qdk.simulation. Ten kod przedstawia przykłady ustawiania poszczególnych zasad.
from qdk.simulation import NoiseConfig, LossPolicy
noise = NoiseConfig()
noise.x.l = 0.01 # 1% chance of qubit loss after X gates
noise.cz.on_loss = LossPolicy.SKIP # Don't apply CZ to remaining qubit
noise.cx.on_loss = LossPolicy.PROPAGATE # Both qubits are lost from CX gate
noise.rxx.on_loss = LossPolicy.DEGRADE # Apply Rx gate to remaining qubit
noise.ryy.on_loss = LossPolicy.RESIDUAL_S_DAGGER # Apply S-adjoint to remaining qubit
noise.swap.on_loss = LossPolicy.APPLY_ANYWAY # Perform swap anyway
W przypadku wszystkich strategii utraty skonfigurowany szum może nadal wpływać na pozostałe kubity. Na przykład ten kod może nadal stosować szum przerzucania bitów na bramkach CZ nawet wtedy, gdy brakuje jednego z kubitów w bramie CZ.
noise.z.l = 0.01 # Introduce qubit loss
noise.cz.xx = 0.02 # Set correlated bit flip noise on CZ gates
noise.cz.on_loss = LossPolicy.SKIP
Niestandardowe funkcje wewnętrzne szumu
Aby tworzyć bardziej złożone modele szumów, QDK ma niestandardowe funkcje wbudowane szumu dla programów OpenQASM i Q#. Funkcje wewnętrzne szumu zachowują się jak niestandardowe bramy wstawione do programu w celu modelowania skorelowanego szumu. Za pomocą niestandardowych funkcji pierwotnych można modelować szum w bramkach obsługiwanych przez NoiseConfig lub w bramkach niestandardowych.
W tych przykładach pokazano, jak utworzyć niestandardową funkcję intrinsic szumu, która modeluje crosstalk między trzema kubitami. Szum intrinsic stosuje skorelowane przerzucanie bitów do dwóch kubitów po zastosowaniu bramy $CNOT$.
Dodawanie funkcji wewnętrznych szumu do programu Q#
W Q# programach należy użyć @NoiseIntrinsic(), aby zadeklarować funkcję wewnętrzną noise. Następnie użyj intrinsic metody z NoiseConfig , aby skonfigurować szum wewnętrzny.
Aby skonfigurować i użyć przykładowego szumu wewnętrznego, wykonaj następujące kroki w notesie Jupyter .
Zaimportuj wymagane obiekty i ustaw profil docelowy QIR .
from qdk import init, TargetProfile from qdk import qsharp from qdk.simulation import run_qir, NoiseConfig from qdk.widgets import Histogram init(target_profile=TargetProfile.Adaptive_RIF)Q# Napisz program o nazwie
GHZ, który wywołuje funkcję intrinsic odpowiedzialną za szum o nazwieCrosstalk3Qpo każdej bramce $CNOT$.%%qsharp // A noise intrinsic that represents crosstalk on 3 qubits. // In the ideal circuit this is a no-op; the simulator injects // Pauli errors according to the NoiseConfig. @NoiseIntrinsic() operation Crosstalk3Q(q0: Qubit, q1: Qubit, q2: Qubit) : Unit { body intrinsic; } // Prepare a GHZ state on 3 qubits, with crosstalk after each CNOT. operation GHZ() : Result[] { use qs = Qubit[3]; H(qs[0]); CNOT(qs[0], qs[1]); Crosstalk3Q(qs[0], qs[1], qs[2]); // crosstalk hits all 3 qubits CNOT(qs[1], qs[2]); Crosstalk3Q(qs[0], qs[1], qs[2]); // crosstalk again MResetEachZ(qs) }Skonfiguruj tabelę szumów dla funkcji intrynsycznej. Ustaw liczbę kubitów, typy szumów i prawdopodobieństwo dla każdego typu szumu.
noise = NoiseConfig() table = noise.intrinsic("Crosstalk3Q", num_qubits=3) table.ixx = 0.10 # 10% XX on qubits 1-2 table.xxi = 0.05 # 5% XX on qubits 0-1Skompiluj program na QIR.
qir = qsharp.compile("GHZ()")Uruchom symulację w symulatorze stabilizatora i wykreślij histogram wyników.
result = run_qir(qir, shots=1000, noise=noise, type="stabilizer") Histogram(result)Aby porównać wynik z symulacją bez szumu, uruchom symulację ponownie bez modelu szumu.
result = run_qir(qir, shots=1000, type="stabilizer") Histogram(result)
Dodawanie instrukcji wewnętrznych szumu do programu OpenQASM
W OpenQASM programach użyj polecenia @qdk.qir.noise_intrinsic, aby utworzyć funkcję intrinsic szumu jako definicję bramki niestandardowej. Następnie użyj intrinsic metody z NoiseConfig , aby skonfigurować szum wewnętrzny.
Aby napisać program OpenQASM z elementem intrinsic noise o nazwie crosstalk_3q i skompilować program do QIR, uruchom ten kod w notesie Jupyter.
from qdk.openqasm import compile, OutputSemantics
from qdk import TargetProfile
from qdk.simulation import run_qir, NoiseConfig
from qdk.widgets import Histogram
qasm_source = """
OPENQASM 3.0;
include "stdgates.inc";
// A noise intrinsic that represents crosstalk on 3 qubits.
// In the ideal circuit this is a no-op; the simulator injects
// Pauli errors according to the NoiseConfig.
@qdk.qir.noise_intrinsic
gate crosstalk_3q q0, q1, q2 {}
qubit[3] qs;
// Prepare a GHZ state on 3 qubits, with crosstalk after each CNOT.
h qs[0];
cx qs[0], qs[1];
crosstalk_3q qs[0], qs[1], qs[2]; // crosstalk hits all 3 qubits
cx qs[1], qs[2];
crosstalk_3q qs[0], qs[1], qs[2]; // crosstalk again
bit[3] res = measure qs;
"""
qir_qasm = compile(
qasm_source,
output_semantics=OutputSemantics.OpenQasm,
target_profile=TargetProfile.Base,
)
Aby skonfigurować szum samoistny i uruchomić symulację, uruchom ten kod.
noise = NoiseConfig()
table = noise.intrinsic("crosstalk_3q", num_qubits=3)
table.ixx = 0.10 # 10% XX on qubits 1-2
table.xxi = 0.05 # 5% XX on qubits 0-1
result = run_qir(
qir_qasm,
shots=1000,
noise=noise,
type="stabilizer",
)
Histogram(result)