Zadávání možností Estimátoru

Verze balíčků

Kód na této stránce byl vyvinut za použití následujících požadavků. Doporučujeme používat tyto verze nebo novější.

qiskit[all]~=2.5.2
qiskit-ibm-runtime~=0.47.0

Možnosti můžeš použít k přizpůsobení primitivu Estimator. Ačkoli je rozhraní metody run() primitivů společné pro všechny implementace, jejich možnosti nikoli. Prostuduj si reference API pro informace o možnostech qiskit.primitives.BaseEstimatorV2 a qiskit_aer.BaseEstimatorV2.

Poznámky:

Poznámky k zadávání možností v primitivech Estimator

Dostupné možnosti si můžeš prohlédnout a aktualizovat jejich hodnoty během inicializace Estimátoru nebo po ní.
K aplikování změn atributu options použij metodu update().
Pokud pro možnost nezadáš hodnotu, obdrží speciální hodnotu Unset a použijí se výchozí hodnoty serveru.
Atribut options je Python typ dataclass. Ke konverzi na slovník můžeš použít vestavěnou metodu asdict.

Nastavení možností Estimátoru

Možnosti můžeš nastavit při inicializaci Estimátoru, po inicializaci Estimátoru nebo (pouze pro precision) v metodě run().

Inicializace primitivu

Při inicializaci Estimátoru můžeš předat instanci třídy options nebo slovník, přičemž Estimator vytvoří kopii těchto možností. Změna původního slovníku nebo instance options proto neovlivní možnosti vlastněné primitivem.

Třída Options

Při vytváření instance třídy Estimator můžeš předat instanci třídy options. Tyto možnosti budou poté aplikovány při použití metody run() k provedení výpočtu. Možnosti zadávej v tomto formátu: options.option.sub-option.sub-sub-option = choice. Například: options.dynamical_decoupling.enable = True

Příklad:

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

_needed = {"qiskit": "qiskit", "qiskit_ibm_runtime": "qiskit-ibm-runtime"}
_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")

from qiskit_ibm_runtime import QiskitRuntimeService

# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0
# from qiskit_ibm_runtime import Estimator
# from qiskit_ibm_runtime.options import EstimatorOptions

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_estimator import Estimator
from qiskit_ibm_runtime.options_models import EstimatorOptions

service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)

options = EstimatorOptions(
    resilience_level=2,
    resilience={"zne_mitigation": True, "zne": {"noise_factors": [1, 3, 5]}},
)

# or...
options = EstimatorOptions()
options.resilience_level = 2
options.resilience.zne_mitigation = True
options.resilience.zne.noise_factors = [1, 3, 5]

estimator = Estimator(mode=backend, options=options)

Slovník

Možnosti pro inicializaci Estimátoru můžeš zadat jako slovník.

from qiskit_ibm_runtime import QiskitRuntimeService

# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0
# from qiskit_ibm_runtime import Estimator

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_estimator import Estimator

service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)

# Setting options during initialization
estimator = Estimator(
    backend,
    options={
        "resilience_level": 2,
        "resilience": {
            "zne_mitigation": True,
            "zne": {"noise_factors": [1, 3, 5]},
        },
    },
)

Aktualizace možností po inicializaci

Možnosti můžeš zadat v tomto formátu: estimator.options.option.sub-option.sub-sub-option = choice, abys využil/a automatické doplňování, nebo použij metodu update() pro hromadné aktualizace.

Třídu možností Estimator (EstimatorOptions) není nutné instancovat, pokud nastavuješ možnosti až po inicializaci primitivu.

from qiskit_ibm_runtime import QiskitRuntimeService

# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0
# from qiskit_ibm_runtime import Estimator

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_estimator import Estimator

service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)

estimator = Estimator(mode=backend)

# Setting options after initialization
# This uses auto-complete.
estimator.options.default_precision = 0.01
# This does bulk update.
estimator.options.update(
    default_precision=0.02, resilience={"zne_mitigation": True}
)

Metoda Run()

Jediné hodnoty, které můžeš předat do run(), jsou ty definované v rozhraní, tedy precision pro Estimátor. Tímto se přepíše hodnota nastavená pro default_precision pro aktuální spuštění.

from qiskit_ibm_runtime import QiskitRuntimeService

# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0
# from qiskit_ibm_runtime import Estimator

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_estimator import Estimator
from qiskit.circuit.library import random_iqp
from qiskit.transpiler import generate_preset_pass_manager
from qiskit.quantum_info import SparsePauliOp

service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)

circuit1 = random_iqp(3)
circuit1.measure_all()
circuit2 = random_iqp(3)
circuit2.measure_all()

observable = SparsePauliOp("Z" * 3)

pass_manager = generate_preset_pass_manager(
    optimization_level=3, backend=backend
)

transpiled1 = pass_manager.run(circuit1)
transpiled2 = pass_manager.run(circuit2)
isa_observable1 = observable.apply_layout(transpiled1.layout)
isa_observable2 = observable.apply_layout(transpiled2.layout)

estimator = Estimator(mode=backend)
# Default precision to use if not specified in run()
estimator.options.default_precision = 0.01
# Run two circuits, requiring a precision of .02 for both.
estimator.run(
    [(transpiled1, isa_observable1), (transpiled2, isa_observable2)],
    precision=0.02,
)

<RuntimeJobV2('dab7lhjvpcac73ddekcg', 'estimator')>

Speciální případ: přesnost

Metoda Estimator.run přijímá dva argumenty: seznam PUBů, z nichž každý může zadat vlastní hodnotu přesnosti pro daný PUB, a pojmenovaný argument precision. Tyto hodnoty přesnosti jsou součástí rozhraní pro spouštění Estimatoru a jsou nezávislé na možnostech Estimatoru v Qiskit Runtime. Mají přednost před hodnotami zadanými jako možnosti, aby byla zachována shoda s abstrakcí Estimatoru.

Pokud však precision není zadána žádným PUBem ani v klíčovém argumentu run (nebo pokud jsou všechny None), použije se hodnota přesnosti z možností, zejména default_precision.

poznámka

Tyto parametry přesnosti slouží pouze k zadání cílové přesnosti a není zaručeno, že výsledky zadané přesnosti skutečně dosáhnou.

Všimni si, že možnosti Estimátoru obsahují jak default_shots, tak default_precision. Protože je však twirling hradel ve výchozím nastavení povolen, součin num_randomizations a shots_per_randomization má přednost před těmito dvěma možnostmi.

Konkrétně pro libovolný PUB Estimátoru:

Pokud PUB specifikuje přesnost, použij tuto hodnotu.
Pokud je pojmenovaný argument precision zadán v run, použij tuto hodnotu.
Pokud je povoleno twirling (ve výchozím nastavení True), použije se součin num_randomizations a shots_per_randomization, zadaný v možnostech twirling.
Pokud je zadáno estimator.options.default_shots, použij tuto hodnotu k řízení množství dat.
Pokud je zadáno estimator.options.default_precision, použij tuto hodnotu.

Například pokud je přesnost zadána na všech čtyřech místech, použije se ta s nejvyšší prioritou (přesnost zadaná v PUBu).

poznámka

Ačkoli přesnost zadaná v PUBu a v run má vyšší prioritu, úloha selže, pokud je povoleno twirling a součin num_randomizations a shots_per_randomization je menší než počet shotů potřebných k dosažení dané přesnosti. V tomto scénáři není Estimator schopen rozdělit shoty mezi zadané num_randomizations.

poznámka

Přesnost je nepřímo úměrná spotřebě času QPU. To znamená, čím nižší přesnost, tím více času QPU je potřeba ke spuštění.

from qiskit_ibm_runtime import QiskitRuntimeService

# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0
# from qiskit_ibm_runtime import Estimator

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_estimator import Estimator
from qiskit.circuit.library import random_iqp
from qiskit.transpiler import generate_preset_pass_manager
from qiskit.quantum_info import SparsePauliOp

service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)

observable = SparsePauliOp("Z" * 3)

circuit = random_iqp(3)
circuit.measure_all()

pass_manager = generate_preset_pass_manager(
    optimization_level=3, backend=backend
)

isa_circuit = pass_manager.run(circuit)
isa_observable = observable.apply_layout(isa_circuit.layout)

# Setting precision during primitive initialization
estimator = Estimator(mode=backend, options={"default_precision": 0.05})

# Run with precision=0.02, overwriting the default.
estimator.run(
    [(isa_circuit, isa_observable1)],
    precision=0.02,
)

<RuntimeJobV2('dab7ljjvpcac73ddekgg', 'estimator')>

Vypnutí veškerého zmírňování a potlačování chyb

Veškeré zmírňování a potlačování chyb můžeš vypnout, pokud například provádíš výzkum vlastních technik zmírňování. Toho dosáhneš nastavením resilience_level = 0.

Příklad:

from qiskit_ibm_runtime import QiskitRuntimeService

# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0
# from qiskit_ibm_runtime import Estimator

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_estimator import Estimator

# Define the service.  This allows you to access an IBM QPU.
service = QiskitRuntimeService()

# Get a backend
backend = service.least_busy(operational=True, simulator=False)

# Define Estimator
estimator = Estimator(backend)

options = estimator.options

# Turn off all error mitigation and suppression
options.resilience_level = 0

Dostupné možnosti

Následující informace dokumentují možnosti z nejnovější verze qiskit-ibm-runtime. Chceš-li zobrazit starší verze možností, navštiv referenci API qiskit-ibm-runtime a vyber předchozí verzi.

default_shots

Celkový počet shotů k použití na obvod na konfiguraci.

Volby: Celé číslo >= 0

Výchozí: None

Dokumentace API default_shots

default_precision

Výchozí přesnost pro libovolný PUB nebo volání run(), které ji nespecifikuje.

Volby: Float > 0

Výchozí: 0.015625 (1 / sqrt(4096))

Dokumentace API default_precision

dynamical_decoupling

Ovládání nastavení zmírňování chyb pomocí dynamického oddělování.

Dokumentace API dynamical_decoupling

dynamical_decoupling.enable

Volby: True, False

Výchozí: False

dynamical_decoupling.extra_slack_distribution

Volby: middle, edges

Výchozí: middle

dynamical_decoupling.scheduling_method

Možnosti: asap, alap Výchozí: alap

dynamical_decoupling.sequence_type

Možnosti: XX, XpXm, XY4 Výchozí: XX

dynamical_decoupling.skip_reset_qubits

Možnosti: True, False Výchozí: False

environment

Dokumentace API environment

environment.job_tags

Seznam značek.

Možnosti: Žádné

Výchozí: Žádná

environment.log_level

Možnosti: DEBUG, INFO, WARNING, ERROR, CRITICAL

Výchozí: WARNING

environment.private

Volby: True, False

Výchozí: False

execution

Dokumentace API execution

execution.init_qubits

Zda resetovat qubity do základního stavu pro každý shot.

Volby: True, False

Výchozí: True

execution.rep_delay

Zpoždění mezi měřením a následujícím kvantovým obvodem.

Možnosti: Hodnota v rozsahu daném backend.rep_delay_range

Výchozí: Dáno hodnotou backend.default_rep_delay

max_execution_time

Omezuje, jak dlouho může úloha běžet, v sekundách. Podrobnosti najdeš v průvodci maximální doba provádění.

Možnosti: Celé číslo sekund v rozsahu [1, 10800]

Výchozí: 10800 (3 hodiny)

resilience

Pokročilé možnosti odolnosti pro doladění strategie odolnosti.

Dokumentace API resilience

resilience.layer_noise_model

Choices: Sequence[LayerNoiseModel]

Výchozí: None

resilience.measure_mitigation

Volby: True, False

Default: True

resilience.measure_noise_learning

Možnosti pro učení šumu měření.

Dokumentace API resilience.measure_noise_learning

resilience.measure_noise_learning.num_randomizations

Možnosti: Celé číslo >= 1

Default: 32

resilience.pec_mitigation

Volby: True, False

Default: False

resilience.pec

Možnosti zmírnění pomocí pravděpodobnostního rušení chyb.

Dokumentace API resilience.pec

resilience.pec.max_overhead

Možnosti: None, celé číslo >= 1

Default: 100

resilience.pec.noise_gain

Možnosti: auto, desetinné číslo v rozsahu [0, 1]

Volby: Celé číslo, auto

resilience.zne_mitigation

Volby: True, False

Default: False

resilience.zne

Dokumentace API resilience.zne

resilience.zne.amplifier

Choices: gate_folding, gate_folding_front, gate_folding_back, pea

Default: gate_folding

resilience.zne.extrapolated_noise_factors

Možnosti: Seznam desetinných čísel

Default: [0, *noise_factors]

resilience.zne.extrapolator

Možnosti: Jedna nebo více z: exponential, linear, double_exponential, polynomial_degree_(1 <= k <= 7), fallback

Default: (exponential, linear)

resilience.zne.noise_factors

Možnosti: Seznam desetinných čísel; každé desetinné číslo >= 1

Výchozí: (1, 1.5, 2) pro PEA, jinak (1, 3, 5)

resilience_level

Kolik odolnosti vybudovat proti chybám. Vyšší úrovně generují přesnější výsledky za cenu delší doby zpracování. Více informací najdeš v části úrovně odolnosti v tématu Správa šumu.

Choices: 0, 1, 2

Default: 1

Dokumentace API resilience_level

simulator

Možnosti k předání při simulaci backendu

Dokumentace API simulator

simulator.basis_gates

Možnosti: Seznam názvů základních hradel, na které se má rozbalit

Výchozí: Sada všech základních hradel podporovaných simulátorem Qiskit Aer

simulator.coupling_map

Možnosti: Seznam orientovaných dvouqubitových interakcí

Výchozí: Žádná, což znamená žádná omezení konektivity (plná konektivita).

simulator.noise_model

Možnosti: Qiskit Aer NoiseModel nebo jeho reprezentace

Výchozí: None

simulator.seed_simulator

Možnosti: Celé číslo

Výchozí: None

twirling

Možnosti twirlingu

Dokumentace API twirling

twirling.enable_gates

Možnosti: True, False

Výchozí: False

twirling.enable_measure

Možnosti: True, False

Výchozí: True

twirling.num_randomizations

Možnosti: auto, celé číslo >= 1

Volby: Celé číslo, auto

twirling.shots_per_randomization

Možnosti: auto, celé číslo >= 1

Volby: Celé číslo, auto

twirling.strategy

Choices: active, active-circuit, active-accum, all

Default: active-accum

experimental

Experimentální možnosti, pokud jsou k dispozici.

Kompatibilita funkcí

Určité funkce runtime nelze používat společně v jedné úloze. Klikni na příslušnou záložku, kde najdeš seznam funkcí, které jsou nekompatibilní s vybranou funkcí:

Frakční hradla

Nekompatibilní s:

Twirlingem hradel
PEA
PEC

Gate-folding ZNE

Může nefungovat při použití vlastních hradel. Nekompatibilní s:

Twirling hradel

Nekompatibilní s:

Frakčními hradly
Stretches

Ostatní poznámky:

Twirling měření lze aplikovat pouze na terminální měření.
Nefunguje s ne-Cliffordovskými provazujícími hradly.

PEA

Nekompatibilní s:

Frakčními hradly
Gate-folding ZNE
PEC

PEC

Nekompatibilní s:

Frakčními hradly
Gate-folding ZNE
PEA

Další kroky

Doporučení

Najdi více podrobností o metodách Estimator v referenci API Estimátoru.
Rozhodni se, v jakém režimu spuštění chceš spustit svou úlohu.
Zjisti více o správě šumu s Estimátorem.

Nastavení možností Estimátoru​

Inicializace primitivu​

Třída Options​

Slovník​

Aktualizace možností po inicializaci​

Metoda Run()​

Speciální případ: přesnost​

Vypnutí veškerého zmírňování a potlačování chyb​

Dostupné možnosti​

Kompatibilita funkcí​

Další kroky​

Nastavení možností Estimátoru

Inicializace primitivu

Třída Options

Slovník

Aktualizace možností po inicializaci

Metoda Run()

Speciální případ: přesnost

Vypnutí veškerého zmírňování a potlačování chyb

Dostupné možnosti

Kompatibilita funkcí

Další kroky