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.5.2
qiskit-ibm-runtime~=0.47.0

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 crei un'istanza della classe Estimator, 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 — 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)

Dizionario

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

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

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.

Non è necessario istanziare la classe options di Estimator (EstimatorOptions) se stai impostando le opzioni dopo l'inizializzazione della primitiva.

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

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

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

Caso speciale: precision

Il metodo Estimator.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:

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

Ad esempio, se precision è specificato in tutti e quattro i punti, viene usato quello con la 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, Estimator 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

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

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

Opzioni disponibili

Le informazioni seguenti documentano 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.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_model

Choices: Sequence[LayerNoiseModel]

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

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

Quanta 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

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 orientate (dirette) 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:

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

Consigli

Trova ulteriori dettagli sui metodi Estimator nel riferimento API di Estimator.
Decidi in quale modalità di esecuzione eseguire il tuo job.
Scopri la gestione del rumore con Estimator.

Impostare le opzioni di Estimator​

Inizializzazione della primitiva​

Classe Options​

Dizionario​

Aggiornare le opzioni dopo l'inizializzazione​

Metodo Run()​

Caso speciale: precision​

Disattivare tutte le mitigazioni e soppressioni degli errori​

Opzioni disponibili​

Compatibilità delle funzionalità​

Prossimi passi​

Impostare le opzioni di Estimator

Inizializzazione della primitiva

Classe Options

Dizionario

Aggiornare le opzioni dopo l'inizializzazione

Metodo Run()

Caso speciale: precision

Disattivare tutte le mitigazioni e soppressioni degli errori

Opzioni disponibili

Compatibilità delle funzionalità

Prossimi passi