Vai al contenuto principale

Specificare le opzioni di Estimator

Versioni dei package

Il codice di questa pagina è stato sviluppato usando i seguenti requisiti. Si raccomanda di usare queste versioni o versioni più recenti.

qiskit[all]~=2.4.0
qiskit-ibm-runtime~=0.46.1

Puoi usare le opzioni per personalizzare la primitiva Estimator. Sebbene l'interfaccia del metodo run() delle primitive sia comune a tutte le implementazioni, le loro opzioni non lo sono. Consulta i riferimenti API per informazioni sulle opzioni di qiskit.primitives.BaseEstimatorV2 e qiskit_aer.BaseEstimatorV2.

Note :

Note sulla specifica delle opzioni nelle primitive Estimator
  • Puoi vedere le opzioni disponibili e aggiornare i valori delle opzioni durante o dopo l'inizializzazione di Estimator.
  • Usa il metodo update() per applicare modifiche all'attributo options.
  • Se non specifichi un valore per un'opzione, le viene assegnato un valore speciale Unset e vengono usati i valori predefiniti del server.
  • L'attributo options è del tipo Python dataclass. Puoi usare il metodo integrato asdict per convertirlo in un dizionario.

Impostare le opzioni di Estimator​

Puoi impostare le opzioni durante l'inizializzazione di Estimator, dopo l'inizializzazione di Estimator, oppure (solo per precision) nel metodo run().

Inizializzazione della primitiva​

Puoi passare un'istanza della classe options o un dizionario durante l'inizializzazione di Estimator, che ne fa una copia. Pertanto, modificare il dizionario originale o l'istanza options non influisce sulle opzioni di proprietà della primitiva.

Classe Options​

Quando si crea un'istanza della classe EstimatorV2, puoi passare un'istanza della classe options. Tali opzioni verranno quindi applicate quando usi run() per eseguire il calcolo. Specifica le opzioni in questo formato: options.option.sub-option.sub-sub-option = choice. Ad esempio: options.dynamical_decoupling.enable = True

Esempio:

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

Dizionario​

Puoi specificare le opzioni come dizionario durante l'inizializzazione di Estimator.

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]},
        },
    },
)

Aggiornare le opzioni dopo l'inizializzazione​

Puoi specificare le opzioni in questo formato: estimator.options.option.sub-option.sub-sub-option = choice per sfruttare il completamento automatico, oppure usare il metodo update() per eseguire aggiornamenti in blocco.

La classe options di EstimatorV2 (EstimatorOptions) non deve essere istanziata se stai impostando le opzioni dopo l'inizializzazione della primitiva.

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

Metodo Run()​

Gli unici valori che puoi passare a run() sono quelli definiti nell'interfaccia. Ovvero precision per Estimator. Questo sovrascrive qualsiasi valore impostato per default_precision per l'esecuzione corrente.

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('d7amh42k86tc73a1sa20', 'estimator')>

Caso speciale: precision​

Il metodo EstimatorV2.run accetta due argomenti: una lista di PUB, ognuno dei quali può specificare un valore di precision specifico per PUB, e un argomento keyword precision. Questi valori di precision fanno parte dell'interfaccia di esecuzione di Estimator, e sono indipendenti dalle opzioni di Runtime Estimator. Hanno la precedenza su qualsiasi valore specificato come opzione, al fine di rispettare l'astrazione di Estimator.

Tuttavia, se precision non è specificato da alcun PUB né nell'argomento keyword run (o se sono tutti None), viene usato il valore di precision dalle opzioni, in particolare default_precision.

nota

Questi parametri di precision servono solo per specificare la precision target, e non è garantito che i risultati raggiungano la precision specificata.

Nota che le opzioni di Estimator contengono sia default_shots che default_precision. Tuttavia, poiché gate-twirling è abilitato per impostazione predefinita, il prodotto di num_randomizations e shots_per_randomization ha la precedenza su queste due opzioni.

Nello specifico, per ogni PUB di Estimator:

  1. Se il PUB specifica precision, usa quel valore.
  2. Se l'argomento keyword precision è specificato in run, usa quel valore.
  3. Se twirling è abilitato (True per impostazione predefinita), viene usato il prodotto di num_randomizations e shots_per_randomization, come specificato nelle opzioni twirling.
  4. Se estimator.options.default_shots è specificato, usa quel valore per controllare la quantità di dati.
  5. Se estimator.options.default_precision è specificato, usa quel valore.

Ad esempio, se precision è specificato in tutti e quattro i posti, viene usato quello con priorità più alta (precision specificato nel PUB).

nota

Sebbene la precision specificata nel PUB e in run abbia una priorità più alta, il job fallisce se twirling è abilitato e il prodotto di num_randomizations e shots_per_randomization è minore degli shot necessari per raggiungere la precision. In questo scenario, EstimatorV2 non è in grado di allocare gli shot tra i num_randomizations specificati.

nota

La precision scala inversamente con l'utilizzo. Ovvero, minore è la precision, più tempo QPU è necessario per eseguire.

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('d8286b00bvlc73d1vn50', 'estimator')>

Disattivare tutte le mitigazioni e soppressioni degli errori​

Puoi disattivare tutte le mitigazioni e soppressioni degli errori se, ad esempio, stai facendo ricerca sulle tue tecniche di mitigazione. Per farlo, imposta resilience_level = 0.

Esempio:

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

Opzioni disponibili​

La tabella seguente documenta le opzioni dell'ultima versione di qiskit-ibm-runtime. Per vedere le versioni di opzioni precedenti, visita il riferimento API di qiskit-ibm-runtime e seleziona una versione precedente.

default_shots

Il numero totale di shot da usare per circuito per configurazione.

Scelte: Intero >= 0

Predefinito: None

Documentazione API default_shots

default_precision

La precision predefinita da usare per qualsiasi PUB o chiamata run() che non ne specifica una.

Scelte: Float > 0

Predefinito: 0.015625 (1 / sqrt(4096))

Documentazione API default_precision

dynamical_decoupling

Controlla le impostazioni di mitigazione degli errori di dynamical decoupling.

Documentazione API dynamical_decoupling

dynamical_decoupling.enable

Scelte: True, False

Predefinito: False

dynamical_decoupling.extra_slack_distribution

Scelte: middle, edges

Predefinito: middle

dynamical_decoupling.scheduling_method

Scelte: asap, alap Predefinito: alap

dynamical_decoupling.sequence_type

Scelte: XX, XpXm, XY4 Predefinito: XX

dynamical_decoupling.skip_reset_qubits

Scelte: True, False Predefinito: False

environment

Documentazione API environment

environment.callback

Funzione callable che riceve l'ID del job e il risultato del job.

Scelte: None

Predefinito: None

environment.job_tags

Lista di tag.

Scelte: None

Predefinito: None

environment.log_level

Scelte: DEBUG, INFO, WARNING, ERROR, CRITICAL

Predefinito: WARNING

environment.private

Scelte: True, False

Predefinito: False

execution

Documentazione API execution

execution.init_qubits

Indica se resettare i qubit allo stato fondamentale per ogni shot.

Scelte: True, False

Predefinito: True

execution.rep_delay

Il ritardo tra una misurazione e il successivo circuito quantistico.

Scelte: Valore nell'intervallo fornito da backend.rep_delay_range

Predefinito: Dato da backend.default_rep_delay

max_execution_time

Limita per quanto tempo può essere eseguito un job, in secondi. Consulta la guida sul tempo massimo di esecuzione per i dettagli.

Scelte: Numero intero di secondi nell'intervallo [1, 10800]

Predefinito: 10800 (3 ore)

resilience

Opzioni avanzate di resilienza per regolare con precisione la strategia di resilienza.

Documentazione API resilience

resilience.layer_noise_learning

Opzioni per l'apprendimento del rumore a strati.

Documentazione API resilience.layer_noise_learning

resilience.layer_noise_learning.layer_pair_depths

Scelte: list[int] di 2-10 valori nell'intervallo [0, 200]

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

resilience.layer_noise_learning.max_layers_to_learn

Scelte: None, Intero >= 1

Predefinito: 4

resilience.layer_noise_learning.num_randomizations

Scelte: Intero >= 1

Predefinito: 32

resilience.layer_noise_learning.shots_per_randomization

Scelte: Intero >= 1

Predefinito: 128

resilience.layer_noise_model

Scelte: NoiseLearnerResult, Sequence[LayerError]

Predefinito: None

resilience.measure_mitigation

Scelte: True, False

Predefinito: True

resilience.measure_noise_learning

Opzioni per l'apprendimento del rumore di misurazione.

Documentazione API resilience.measure_noise_learning

resilience.measure_noise_learning.num_randomizations

Scelte: Intero >= 1

Predefinito: 32

resilience.measure_noise_learning.shots_per_randomization

Scelte: Intero, auto

Predefinito: auto

resilience.pec_mitigation

Scelte: True, False

Predefinito: False

resilience.pec

Opzioni di mitigazione della cancellazione probabilistica degli errori.

Documentazione API resilience.pec

resilience.pec.max_overhead

Scelte: None, Intero >= 1

Predefinito: 100

resilience.pec.noise_gain

Scelte: auto, float nell'intervallo [0, 1]

Predefinito: auto

resilience.zne_mitigation

Scelte: True, False

Predefinito: False

resilience.zne
resilience.zne.amplifier

Scelte: gate_folding, gate_folding_front, gate_folding_back, pea

Predefinito: gate_folding

resilience.zne.extrapolated_noise_factors

Scelte: Lista di float

Predefinito: [0, *noise_factors]

resilience.zne.extrapolator

Scelte: Uno o più di: exponential, linear, double_exponential, polynomial_degree_(1 <= k <= 7), fallback

Predefinito: (exponential, linear)

resilience.zne.noise_factors

Scelte: Lista di float; ogni float >= 1

Predefinito: (1, 1.5, 2) per PEA, e (1, 3, 5) altrimenti

resilience_level

Quanto resilienza costruire contro gli errori. Livelli più alti generano risultati più accurati a scapito di tempi di elaborazione più lunghi. Consulta la sezione livelli di resilienza nel topic Gestione del rumore per saperne di più.

Scelte: 0, 1, 2

Predefinito: 1

Documentazione API resilience_level

seed_estimator

Scelte: Intero

Predefinito: None

seed_estimator

simulator

Opzioni da passare durante la simulazione di un backend

Documentazione API simulator

simulator.basis_gates

Scelte: Lista di nomi di gate di base su cui decomporre

Predefinito: L'insieme di tutti i gate di base supportati dal simulatore Qiskit Aer

simulator.coupling_map

Scelte: Lista di interazioni bidirezionali a due qubit

Predefinito: None, che implica nessun vincolo di connettività (connettività completa).

simulator.noise_model

Scelte: Qiskit Aer NoiseModel, o la sua rappresentazione

Predefinito: None

simulator.seed_simulator

Scelte: Intero

Predefinito: None

twirling

Opzioni di twirling

Documentazione API twirling

twirling.enable_gates

Scelte: True, False

Predefinito: False

twirling.enable_measure

Scelte: True, False

Predefinito: True

twirling.num_randomizations

Scelte: auto, Intero >= 1

Predefinito: auto

twirling.shots_per_randomization

Scelte: auto, Intero >= 1

Predefinito: auto

twirling.strategy

Scelte: active, active-circuit, active-accum, all

Predefinito: active-accum

experimental

Opzioni sperimentali, quando disponibili.

Compatibilità delle funzionalità​

Alcune funzionalità di runtime non possono essere usate insieme in un singolo job. Clicca sulla scheda appropriata per un elenco delle funzionalità incompatibili con la funzionalità selezionata:

Fractional gates

Incompatibile con:

  • Gate twirling
  • PEA
  • PEC
Gate-folding ZNE

Potrebbe non funzionare quando si usano gate personalizzati. Incompatibile con:

  • PEA
  • PEC
Gate twirling

Incompatibile con:

  • Fractional gates
  • Stretches

Altre note:

  • Il measurement twirling può essere applicato solo alle misurazioni terminali.
  • Non funziona con entangler non-Clifford.
PEA

Incompatibile con:

  • Fractional gates
  • Gate-folding ZNE
  • PEC
PEC

Incompatibile con:

  • Fractional gates
  • Gate-folding ZNE
  • PEA

Prossimi passi​

Raccomandazioni
Fonte: IBM Quantum docs — aggiornato il 15 giu 2026
Versione inglese su doQumentation — aggiornata il 15 giu 2026
Questa traduzione si basa sulla versione inglese del 13 mag 2026
Problema con il sito o la traduzione?Problema di contenuto? Modifica su IBM Quantum docs