Přeskočit na hlavní obsah

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 EstimatorV2 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 — required packages for this notebook
!pip install -q qiskit qiskit-ibm-runtime
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit_ibm_runtime import EstimatorV2 as Estimator
from qiskit_ibm_runtime.options 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
from qiskit_ibm_runtime import EstimatorV2 as 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řída options EstimatorV2 (EstimatorOptions) nemusí být instanciována, pokud nastavuješ možnosti po inicializaci primitivu.

from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit_ibm_runtime import EstimatorV2 as 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
from qiskit_ibm_runtime import EstimatorV2 as 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 EstimatorV2.run přijímá dva argumenty: seznam PUBů, z nichž každý může specifikovat PUB-specifickou hodnotu přesnosti, a klíčový argument precision. Tyto hodnoty přesnosti jsou součástí rozhraní pro spouštění Estimátoru a jsou nezávislé na možnostech Estimátoru Runtime. Mají přednost před hodnotami zadanými jako možnosti, aby byla zachována shoda s abstrakcí Estimátoru.

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 výsledky nejsou garantovány na dosažení zadané přesnosti.

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:

  1. Pokud PUB specifikuje přesnost, použij tuto hodnotu.

  2. Pokud je klíčový argument precision zadán v run, použij tuto hodnotu.

  3. Pokud je povoleno twirling (ve výchozím nastavení True), použije se součin num_randomizations a shots_per_randomization, zadaný jako twirling options.

  4. Pokud je zadáno estimator.options.default_shots, použij tuto hodnotu k řízení množství dat.

  5. 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 mají 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í EstimatorV2 schopen rozdělit shoty mezi zadané num_randomizations.

poznámka

Přesnost se škáluje nepřímo k využití. 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
from qiskit_ibm_runtime import EstimatorV2 as 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 EstimatorV2 as Estimator, QiskitRuntimeService

# 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í tabulka dokumentuje 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 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.callback

Volatelná funkce, která přijímá Job ID a Job result.

Možnosti: Žádné

Výchozí: Žádná

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_learning

Možnosti pro učení šumu vrstev.

Dokumentace API resilience.layer_noise_learning

resilience.layer_noise_learning.layer_pair_depths

Možnosti: list[int] s 2–10 hodnotami v rozsahu [0, 200]

Default: (0, 1, 2, 4, 16, 32)

resilience.layer_noise_learning.max_layers_to_learn

Možnosti: Žádná, celé číslo >= 1

Default: 4

resilience.layer_noise_learning.num_randomizations

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

Default: 32

resilience.layer_noise_learning.shots_per_randomization

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

Default: 128

resilience.layer_noise_model

Choices: NoiseLearnerResult, Sequence[LayerError]

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.measure_noise_learning.shots_per_randomization

Možnosti: Celé číslo, auto

Volby: Celé číslo, auto

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
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

seed_estimator

Možnosti: Celé číslo

Výchozí: None

seed_estimator

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

Volby: True, False

twirling.enable_measure

Možnosti: True, False

Výchozí hodnota: 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:

  • PEA
  • PEC
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í
Zdroj: IBM Quantum docs — aktualizováno 1. 9. 2026
Anglická verze na doQumentation — aktualizováno 1. 9. 2026
Problém s webem nebo překladem?Problém v obsahu? Upravit v IBM Quantum docs