Szybki start

---

title: Szybki start description: Przewodnik szybkiego startu po dodatku Qiskit Shaded lightcones (qiskit-addon-slc)

Ten przewodnik pokazuje minimalny działający przykład pakietu qiskit-addon-slc. Oblicza zacieniowany stożek świetlny, aby zmniejszyć koszt próbkowania probabilistycznej redukcji błędów (PEC).

PEC łagodzi szum bramek, próbkując z rozkładu quasiprawdopodobieństwa odwrotnego kanału szumu. Jego koszt próbkowania rośnie z każdym składnikiem błędu, który trzeba złagodzić; jednak nie każdy błąd wpływa na obserwablę jednakowo. Błąd poza przyczynowym stożkiem świetlnym obserwabli nie może wpłynąć na mierzoną wartość oczekiwaną, a nawet wewnątrz stożka niektóre błędy są bardziej szkodliwe od innych. Zacieniowany stożek świetlny określa to ilościowo, ograniczając wpływ każdego składnika błędu Pauliego na obserwablę. Obcięcie składników błędu o najmniejszym wpływie zmniejsza model szumu, który PEC musi łagodzić, obniżając koszt próbkowania kosztem niewielkiego, ograniczonego obciążenia.

Aby zobaczyć, jak zbudować realistyczny przepływ pracy i uruchomić go na sprzęcie kwantowym, zajrzyj do samouczka Probabilistic error cancellation with shaded lightcones na IBM Quantum Platform.

1. Przygotuj dane wejściowe dla SLC

Najpierw zbuduj 10-kubitowy obwód Isinga z polem poprzecznym w postaci trotteryzowanej i wybierz jednokubitową obserwablę $Z$ na środkowym kubicie.

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"numpy": "numpy", "qiskit": "qiskit", "qiskit_addon_slc": "qiskit-addon-slc", "samplomatic": "samplomatic"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

import numpy as np
from qiskit import QuantumCircuit
from qiskit.quantum_info import Pauli

def trotter_ising_circuit(num_qubits, num_steps, rx_angle, rzz_angle):
    """Trotterized transverse-field Ising evolution on a 1D chain."""
    circuit = QuantumCircuit(num_qubits)
    for _ in range(num_steps):
        circuit.rx(rx_angle, range(num_qubits))
        circuit.barrier()
        for start in (0, 1):  # even then odd bonds
            for i in range(start, num_qubits - 1, 2):
                circuit.rzz(rzz_angle, i, i + 1)
        circuit.barrier()
    return circuit

num_qubits = 10
circuit = trotter_ising_circuit(
    num_qubits, num_steps=4, rx_angle=np.pi / 16, rzz_angle=-np.pi / 3
)

# Measure <Z> on the middle qubit
observable = Pauli("I" * num_qubits).compose("Z", [num_qubits // 2])

print(f"Observable: {observable}")
circuit.draw("mpl", fold=-1, scale=0.7)

Observable: IIIIZIIIII

SLC działa na zaszumionych warstwach bramek dwukubitowych obwodu. Tutaj używamy samplomatic, aby pogrupować bramki w adnotowane bloki i dołączyć do każdej warstwy dwukubitowej adnotację wstrzykiwania szumu. SLC wymaga, aby każdy zaszumiony blok miał unikalny modifier_ref, co zapewnia inject_noise_strategy="individual_modification"; przy domyślnej strategii samplomatic granice wychodzą błędne albo ich obliczanie nigdy się nie kończy. Następnie generate_noise_model_paulis wylicza składniki błędu Pauliego każdej unikalnej zaszumionej warstwy.

from qiskit_addon_slc.utils import generate_noise_model_paulis
from samplomatic.transpiler import generate_boxing_pass_manager
from samplomatic.utils import find_unique_box_instructions

# Group gates into boxes and annotate each two-qubit layer with a noise-injection point
boxing_pass = generate_boxing_pass_manager(
    inject_noise_targets="all",
    inject_noise_strategy="individual_modification",  # required: one modifier_ref per box
    inject_noise_site="after",
    twirling_strategy="active",
    remove_barriers="never",
)
boxed_circuit = boxing_pass.run(circuit)

# Enumerate the 1- and 2-weight Pauli error terms of each unique noisy layer
noise_model_paulis = generate_noise_model_paulis(
    find_unique_box_instructions(boxed_circuit)
)

num_terms = sum(len(paulis) for paulis in noise_model_paulis.values())
print(f"Noisy layers: {len(noise_model_paulis)}")
print(f"Pauli error terms across all layers: {num_terms}")

Noisy layers: 2
Pauli error terms across all layers: 198

2. Oblicz zacieniowany stożek świetlny

Zacieniowany stożek świetlny powstaje przez przypisanie skali każdemu składnikowi błędu Pauliego w modelu szumu na podstawie tego, jak bardzo wpływa on na wartość oczekiwaną obserwabli. Skale te wynikają z granic błędu w przód i wstecz każdego składnika (opisanych poniżej) oraz z jego stopy błędu:

• compute_forward_bounds ewoluuje każdy składnik błędu w przód do końca obwodu, aby ograniczyć jego wpływ na mierzoną tam obserwablę.

• compute_backward_bounds ewoluuje każdy składnik błędu wstecz do początku obwodu, aby ograniczyć jego wpływ na stan początkowy.

merge_bounds łączy obie granice w jedną na składnik błędu. Każda granica jest skalowana stopą błędu danego składnika. Stopy te zwykle pochodzą z eksperymentu uczenia szumu (takiego jak NoiseLearnerV3); ten przewodnik dla uproszczenia używa stóp losowych.

from qiskit.quantum_info import PauliLindbladMap, QubitSparsePauliList
from qiskit_addon_slc.bounds import (
    compute_backward_bounds,
    compute_forward_bounds,
    merge_bounds,
)

forward_bounds = compute_forward_bounds(
    boxed_circuit, noise_model_paulis, observable
)
backward_bounds = compute_backward_bounds(boxed_circuit, noise_model_paulis)

# Stand-in for rates that would be measured by a noise-learning experiment on hardware
rng = np.random.default_rng(42)
noise_rates = {
    layer_id: PauliLindbladMap.from_components(
        rng.random(len(paulis)) * 5e-3,
        QubitSparsePauliList.from_sparse_list(
            paulis.to_sparse_list(), paulis.num_qubits
        ),
    )
    for layer_id, paulis in noise_model_paulis.items()
}

merged_bounds = merge_bounds(
    boxed_circuit, forward_bounds, backward_bounds, noise_rates
)

Optimal spacetime partitioning not implemented!Just partitioning list of noisy boxes.

W poniższej wizualizacji zacieniowanego stożka świetlnego każdy blok jest zacieniowany według tego, jak silnie błędy w tym miejscu mogą wpływać na obserwablę. Jasne bloki mają największe granice, a bloki zanikające w tle zawierają składniki błędu, które mało wpływają na obliczenia -- te błędy są naturalnymi kandydatami do usunięcia z modelu szumu. Wartości w poniższej wizualizacji są sumami granic błędów wszystkich błędów Pauliego w danym miejscu, dlatego niektóre z nich przekraczają 2.0, czyli granicę dla pojedynczego błędu Pauliego.

from qiskit_addon_slc.visualization import draw_shaded_lightcone

draw_shaded_lightcone(
    boxed_circuit, merged_bounds, noise_model_paulis, fold=-1, scale=0.5
)

3. Zmniejsz koszt próbkowania

compute_local_scales zamienia zacieniowany stożek świetlny w konkretną konfigurację PEC. Ustala priorytety składników błędu według ich ograniczonego wpływu na obserwablę i obcina te o najmniejszym wpływie, aż zostanie osiągnięte żądane bias_tolerance. Zwraca skale dla każdego składnika błędu: 0.0 dla składników, które należy zignorować podczas łagodzenia, i -1.0 dla składników, które należy łagodzić. Funkcja zwraca też wynikowy narzut kosztu próbkowania ($\gamma^2$) oraz granicę obciążenia resztkowego wynikającego z obcięcia.

Ustawienie bias_tolerance=0.0 łagodzi każdy składnik błędu w przyczynowym stożku świetlnym obserwabli i daje bazowy koszt próbkowania. Dopuszczenie niewielkiego obciążenia pozwala SLC odrzucić składniki o małym wpływie i jeszcze bardziej obniżyć ten koszt.

from qiskit_addon_slc.bounds import compute_local_scales

_, full_cost, full_bias = compute_local_scales(
    boxed_circuit, merged_bounds, noise_rates, bias_tolerance=0.0
)
local_scales, reduced_cost, reduced_bias = compute_local_scales(
    boxed_circuit, merged_bounds, noise_rates, bias_tolerance=0.05
)

print(
    f"Full PEC (bias_tolerance=0.0) : sampling cost {full_cost:6.3f}, residual bias {full_bias:5.3f}"
)
print(
    f"Shaded   (bias_tolerance=0.05): sampling cost {reduced_cost:6.3f}, residual bias {reduced_bias:5.3f}"
)
print(
    f"\nSampling-cost reduction: {(1 - reduced_cost / full_cost):.0%} for <= 0.05 bias"
)

Full PEC (bias_tolerance=0.0) : sampling cost 21.206, residual bias 0.000
Shaded   (bias_tolerance=0.05): sampling cost  5.403, residual bias 0.049

Sampling-cost reduction: 75% for <= 0.05 bias