Twórz modele szumu na potrzeby symulacji kwantowych w programie QDK

Element Microsoft Quantum Development Kit (QDK) zawiera zestaw symulatorów kwantowych, które modeluje sposób działania programu na komputerze kwantowym. Programy uruchamiane na komputerze kwantowym zawsze zawierają pewien typ i stopień szumu. Pakiet QDKPython umożliwia tworzenie niestandardowych modeli szumów do użycia w symulacjach za pośrednictwem interfejsu NoiseConfig API.

Aby uzyskać instrukcje dotyczące sposobu instalowania i używania QDK symulatorów, zobacz Uruchamianie symulacji kwantowych za pomocą pakietu QDKPython.

Typy szumów

Każda operacja lub instrukcja w programie kwantowym może powodować szum. W tej tabeli wymieniono wszystkie operacje i instrukcje, dla których można ustawić szum.

Źródło szumu Parametr modelu szumu Opis źródła
bramka $X$ x Bramka jednokubitowa Pauli, przerzucanie bitowe
bramka $Y$ y Bramka jednokubitowa Pauli, negacja bitu i negacja fazy
bramka $Z$ z Bramka jednokubitowa Pauli, odwrócenie fazy
bramka $H$ h Bramka jednokubitowa Hadamard, tworzy stan równej superpozycji
bramka $S$ s Bramka jednokubitowa, przesunięcie fazy pół-pi
bramka $S^\dagger$ s_adj Bramka z pojedynczym kubitem, przylega do $S$
bramka $T$ t Jednokubitowa brama, przesunięcie fazowe o π/4
brama $T^\dagger$ t_adj Bramka jednokubitowa, sprzężona do $T$
bramka $S_X$ sx Bramka z pojedynczym kubitem, półobrót odwrócenia bitu
$S_X^\dagger$ gate sx_adj Bramka z pojedynczym kubitem, przylega do $S_X$
bramka $R_X$ rx Bramka jednokubitowa, ogólny obrót fazowy wokół osi $x$
bramka $R_Y$ ry Bramka jednokubitowa, ogólny obrót fazowy wokół osi $y$
bramka $R_Z$ rz Bramka jednokubitowa, ogólny obrót fazowy wokół osi $z$
bramka $CX$ cx Bramka z dwoma kubitami, brama sterowana $X$
bramka $CY$ cy Bramka z dwoma kubitami, brama sterowana $Y$
bramka $CZ$ cz Bramka z dwoma kubitami, brama sterowana $Z$
bramka $R_{XX}$ rxx Bramka dwukubitowa, analogiczna do $R_X$
bramka $R_{YY}$ ryy Bramka dwukubitowa, analogiczna do bramki $R_Y$
bramka $R_{ZZ}$ rzz Bramka dwukabitowa, analogiczna do $R_Z$
bramka $SWAP$ swap Bramka dwukubitowa, zamienia stany kubitów
bramka $CCX$ ccx Bramka z trzema kubitami, brama sterowana dwoma kubitami $X$
Ruch kubitu mov Ruch kubitu między strefami urządzeń (w przypadku symulacji urządzenia neutralnego atomu)
Pomiar kubitu mz Pomiar pojedynczego kubitu w Paulibazie -$Z$
Pomiar i resetowanie kubitów mresetz Pomiar pojedynczego kubitu i resetowanie do stanu 0

Za pomocą NoiseConfig można zastosować cztery różne rodzaje szumów do wcześniejszych operacji z określonymi prawdopodobieństwami. W tej tabeli wymieniono parametry typu szumu, które można ustawić za pomocą NoiseConfigpolecenia . Zawiera również parametr dla braku szumu.

Typ szumu Parametr modelu szumu Opis szumu Przykładowe użycie Opis przykładu
Pauli szum $X$ x Przerzucanie bitowe noise.z.x = 0.03 Przerzucanie bitów odbywa się w 3% operacji $Z$
Pauli szum $Y$ y Przerzucanie bitowe i przerzucanie fazy noise.sx.y = 0.01 Przerzucanie bitów i przerzucanie faz odbywa się w 1% operacji $S_X$
Pauli szum $Z$ z Odwrócenie fazy noise.h.z = 0.02 Odwrócenie fazy występuje w 2% operacji $H$
Brak szumu i Operacja tożsamości, bez efektu noise.cz.ix = 0.02 Odwrócenie bitu dotyczy jedynie docelowego kubitu w 2% operacji $CZ$.
Utrata kubitu l Kubit zostanie utracony z urządzenia noise.mov.l = 0.03 Kubit gubi się podczas 3% przemieszczeń między strefami urządzenia w komputerze kwantowym opartym na neutralnych atomach

Szum występuje po operacji źródłowej, a nie zamiast operacji źródłowej. Na przykład noise.z.x oznacza, że program stosuje bramę $Z$ do kubitu, a następnie stosuje niezamierzoną bramę $X$. Ponieważ szum ma zastosowanie po źródle, można skonfigurować szum, który ma taki sam efekt jak źródło. Na przykład noise.x.x powoduje niezamierzone odwrócenie bitu po zamierzonym odwróceniu bitu.

Note

Interfejsy API symulacji urządzeń z atomami neutralnymi obsługują zakłócenia z ograniczonej liczby źródeł. Aby uzyskać więcej informacji, zobacz Jak tworzyć modele szumu na potrzeby symulacji urządzeń z atomami neutralnymi w QDK.

Utwórz model szumu

Aby utworzyć model szumu dla symulacji i wyświetlić wpływ tego szumu na wyniki programu kwantowego, wykonaj następujące kroki.

  1. W VS Codeprogramie otwórz menu Widok i wybierz pozycję Paleta poleceń.

  2. Wprowadź Utwórz: Nowy Jupyter Notebook. Jupyter Notebook Pusty plik zostanie otwarty na nowej karcie.

  3. W pierwszej komórce notesu zaimportuj wymagane Python obiekty.

    from qdk import init, TargetProfile
    from qdk.openqasm import compile
    from qdk.simulation import NoiseConfig, run_qir
    from qdk.widgets import Histogram
    
  4. W nowej komórce ustaw profil docelowy urządzenia QIR i skompiluj obwód OpenQASM do QIR.

    init(target_profile=TargetProfile.Base)
    
    qasm_src = """
    include "stdgates.inc";
    qubit[2] qs;
    bit[2] r;
    
    h qs[0];
    t qs[0];
    cx qs[0], qs[1];
    r = measure qs;
    """
    
    qir = compile(qasm_src)
    
  5. Utwórz NoiseConfig obiekt i zbuduj model szumu.

    noise = NoiseConfig()
    
    noise.t.z = 0.01
    noise.cx.zi = 0.02
    

    Ten kod generuje ten model szumu, gdzie współczynnik szumu jest prawdopodobieństwem, że źródło powoduje odpowiedni typ szumu.

    Źródło szumu Typ szumu Wskaźnik szumu
    bramka $T$ Odwrócenie fazy 1%
    bramka $CX$ Odwrócenie fazy na kubicie kontrolnym 2%
  6. Uruchom symulator z modelem szumu i wyświetl histogram wyników pomiaru. Ten kod symuluje 1000 strzałów na symulatorze stabilizatora. Bramka $T$ powoduje rozgałęzianie stabilizatora, a skonfigurowany błąd $Z$ jest losowany po bramie $T$.

    results = run_qir(qir, shots=1000, noise=noise, type="stabilizer")
    Histogram(results, labels="kets")
    
  7. Aby porównać hałaśliwe wyniki z symulacją bez szumu, uruchom symulację ponownie bez modelu szumu.

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

Ustawianie wielu typów szumów w tym samym źródle

Można modelować różne typy szumów na tym samym źródle, z różnymi prawdopodobieństwami dla każdego typu szumu. Na przykład ten kod ustawia 1% szansy, że nastąpi odwrócenie bitu, i 3% szansy, że nastąpi odwrócenie fazy po bramce Hadamard.

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

Podczas konfigurowania wielu typów szumów dla tej samej operacji tylko jeden typ szumu może być stosowany do każdej operacji w programie. Na przykład każda brama Hadamard może mieć szum $X$ lub szum $Z$, ale nie obu naraz.

Funkcje modelu szumu

Zamiast parametrów modelu szumu można użyć tych funkcji szumu do utworzenia modelu szumu.

Ustaw Pauli szum

Aby uwzględnić Pauli szum w modelu, wywołaj set_pauli_noise funkcję na operacji bramki lub ruchu.

W przypadku operacji na pojedynczym kubicie przekaż jednoznakowy ciąg znaków Pauli i szybkość szumu. Na przykład ten kod ustawia 1% szansę, że dojdzie do zmiany stanu bitu podczas przenoszenia kubitu.

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

W przypadku operacji dwukubitowych przekaż dwuznakowy ciąg znaków Pauli i szybkość szumu. Pierwszy znak Pauli ciągu odpowiada szumowi na kubitie sterującym, a drugi znak odpowiada szumowi na kubitie docelowym. Na przykład ten kod ustawia skorelowane odwrócenia fazy po 1% operacji $CX$.

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

Ustaw szum depolaryzacyjny

Funkcja set_depolarizing ustawia równe poziomy dla wszystkich trzech typów szumów Pauli. Na przykład ten kod ustawia 3% prawdopodobieństwo wystąpienia Pauli szumu po operacji $H$ rozłożone równomiernie jako 1% szansę dla każdego z trzech Pauli typów szumów.

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

Ustawianie szumu przerzucania bitów

Aby ustawić szybkość szumu dla przerzucania bitów, użyj set_bitflip funkcji w operacji bramy lub ruchu. Na przykład ten kod ustawia 1% szansę na to, że po operacji $R_Z$ dochodzi do zmiany stanu bitu.

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

Ustaw szum odwrócenia fazy

Aby ustawić szybkość szumu dla przerzucania faz w operacji, użyj set_phaseflip funkcji w operacji bramy lub ruchu. Na przykład ten kod ustawia 1% szansę, że po operacji $R_Y$ wystąpi odwrócenie fazy.

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