Modul de testare locală

Versiuni de pachete

Codul de pe această pagină a fost dezvoltat folosind următoarele cerințe. Îți recomandăm să folosești aceste versiuni sau unele mai noi.

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

Folosește modul de testare locală (disponibil începând cu qiskit-ibm-runtime v0.22.0 sau mai recent) pentru a testa programele înainte de a le ajusta fin și de a le trimite pe hardware cuantic real. După ce folosești modul de testare locală pentru a verifica programul, tot ce trebuie să schimbi este numele Backend-ului pentru a-l rula pe un QPU.

notă

Suportul pentru modul local al primitivului Executor a fost introdus în qiskit-ibm-runtime v0.50.0.

Pentru a folosi modul de testare locală, specifică unul dintre Backend-urile false din qiskit_ibm_runtime.fake_provider sau specifică un Backend Qiskit Aer când instanțiezi un primitiv IBM Quantum® sau o Session.

• Backend-uri false: Backend-urile false din qiskit_ibm_runtime.fake_provider imită comportamentul QPU-urilor IBM® folosind instantanee ale QPU-urilor. Instantaneele QPU conțin informații importante despre QPU, cum ar fi harta de cuplare, porțile de bază și proprietățile qubiților, care sunt utile pentru testarea Transpiler-ului și pentru efectuarea de simulări cu zgomot ale QPU-ului. Modelul de zgomot din instantaneu este aplicat automat în timpul simulării.

• Simulatorul Aer: Simulatoarele din Qiskit Aer oferă simulări de performanță mai ridicată, care pot gestiona Circuit-uri mai mari și modele de zgomot personalizate. O listă de opțiuni pentru metodele de simulare este disponibilă atunci când folosești AerSimulator în modul de testare locală. Vezi exemplul modului de simulare Clifford, care demonstrează cum să simulezi eficient Circuit-uri Clifford cu un număr mare de qubiți.

  Listă de metode de simulare disponibile din Qiskit Aer

  Consultă documentația AerSimulator pentru mai multe informații.

  • "automatic": Metoda de simulare implicită. Selectează automat metoda de simulare, în funcție de circuit și de modelul de zgomot.

  • "statevector": O simulare densă a vectorului de stare care poate eșantiona rezultatele măsurătorilor din Circuit-uri ideale cu toate măsurătorile la sfârșitul Circuit-ului. Pentru simulări cu zgomot, fiecare shot eșantionează aleatoriu un circuit cu zgomot din modelul de zgomot.

  • "density_matrix": O simulare a matricei de densitate care poate eșantiona rezultatele măsurătorilor din Circuit-uri cu zgomot cu toate măsurătorile la sfârșitul Circuit-ului.

  • "stabilizer": Un simulator eficient al stării stabilizatoare Clifford care poate simula Circuit-uri Clifford cu zgomot dacă toate erorile din modelul de zgomot sunt și ele erori Clifford.

  • "extended_stabilizer": Un simulator aproximativ pentru Circuit-uri Clifford + T, bazat pe descompunerea stării într-o combinație de stări stabilizatoare (ranked-stabilizer). Numărul de termeni crește odată cu numărul de porți non-Clifford (T).

  • "matrix_product_state": Un simulator de vector de stare bazat pe rețele tensoriale care folosește o reprezentare de tip Matrix Product State (MPS) pentru stare. Aceasta poate fi realizată cu sau fără trunchierea dimensiunilor legăturilor MPS, în funcție de opțiunile simulatorului. Comportamentul implicit este fără trunchiere.

  • "unitary": O simulare densă a matricei unitare a unui Circuit ideal. Aceasta simulează matricea unitară a Circuit-ului în sine, nu evoluția unei stări cuantice inițiale. Această metodă poate simula doar Gate-uri; nu suportă măsurători, resetări sau zgomot.

  • "superop": O simulare densă a matricei de superoperator a unui Circuit ideal sau cu zgomot. Aceasta simulează matricea de superoperator a Circuit-ului în sine, nu evoluția unei stări cuantice inițiale. Această metodă poate simula Gate-uri și resetări ideale și cu zgomot, dar nu suportă măsurători.

  • "tensor_network": O simulare bazată pe rețele tensoriale care suportă atât vectorul de stare, cât și matricea de densitate. În prezent, aceasta este disponibilă doar pentru GPU și este accelerată prin utilizarea API-urilor cuQuantum cuTensorNet.

Note

• Poți specifica toate opțiunile IBM Quantum Compute în modul de testare locală. Cu Sampler și Estimator de pe partea clientului (introduse în qiskit-ibm-runtime v0.50.0), opțiunile de suprimare și atenuare a erorilor sunt implementate local, astfel încât poți testa local diferite metode de atenuare a erorilor înainte de a consuma timp QPU. Vezi Testează local atenuarea erorilor pentru un exemplu.

Anterior, simulatoarele locale ignorau toate opțiunile, cu excepția shots, în cazul primitivelor vechi (pe partea serverului), deoarece procesarea respectivă avea loc doar pe server.

• Se recomandă să instalezi Qiskit Aer înainte de a folosi Backend-urile false sau simulatoarele Aer, rulând pip install qiskit-aer. Backend-urile false folosesc simulatoarele Aer pe fundal, dacă sunt disponibile, pentru a beneficia de performanța acestora.

Exemplu cu Backend-uri false

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

_needed = {"numpy": "numpy", "qiskit": "qiskit", "qiskit_aer": "qiskit-aer", "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.circuit import QuantumCircuit
from qiskit.transpiler import generate_preset_pass_manager

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

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_sampler import Sampler
from qiskit_ibm_runtime.fake_provider import FakeManilaV2

# Bell Circuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

# Run the Sampler job locally using FakeManilaV2
fake_manila = FakeManilaV2()
pm = generate_preset_pass_manager(backend=fake_manila, optimization_level=1)
isa_qc = pm.run(qc)

# You can use a fixed seed to get fixed results.
options = {"simulator": {"seed_simulator": 42}}
sampler = Sampler(mode=fake_manila, options=options)

result = sampler.run([isa_qc]).result()

Exemple cu AerSimulator

Exemplu cu Session-uri, fără zgomot:

from qiskit_aer import AerSimulator
from qiskit.circuit import QuantumCircuit
from qiskit.transpiler import generate_preset_pass_manager
from qiskit_ibm_runtime import Session

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

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_sampler import Sampler

# Bell Circuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

# Run the Sampler job locally using AerSimulator.
# Session syntax is supported but ignored because local mode doesn't support sessions.
aer_sim = AerSimulator()
pm = generate_preset_pass_manager(backend=aer_sim, optimization_level=1)
isa_qc = pm.run(qc)
with Session(backend=aer_sim) as session:
    sampler = Sampler(mode=session)
    result = sampler.run([isa_qc]).result()

Pentru a simula cu zgomot, specifică un QPU (hardware cuantic) și trimite-l către Aer. Aer construiește un model de zgomot bazat pe datele de calibrare de la acel QPU și instanțiază un Backend Aer cu acel model. Dacă preferi, poți construi un model de zgomot.

atenție

Un QPU poate fi afectat de diferite tipuri de zgomot. Modelul de zgomot Qiskit Aer folosit aici simulează doar o parte dintre ele și, prin urmare, este probabil să fie mai puțin sever decât zgomotul de pe un QPU real.

Pentru detalii despre ce erori sunt incluse la inițializarea unui model de zgomot dintr-un QPU, consultă referința API Aer NoiseModel.

Exemplu cu zgomot:

from qiskit_aer import AerSimulator
from qiskit.circuit import QuantumCircuit
from qiskit.transpiler import generate_preset_pass_manager
from qiskit_ibm_runtime import QiskitRuntimeService

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

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_sampler import Sampler

# Bell Circuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

service = QiskitRuntimeService()

# Specify a QPU to use for the noise model
real_backend = service.least_busy(operational=True, simulator=False)
aer = AerSimulator.from_backend(real_backend)

# Run the Sampler job locally using AerSimulator.
pm = generate_preset_pass_manager(backend=aer, optimization_level=1)
isa_qc = pm.run(qc)
sampler = Sampler(mode=aer)
result = sampler.run([isa_qc]).result()

Simularea Clifford

Deoarece Circuit-urile Clifford pot fi simulate eficient cu rezultate verificabile, simularea Clifford este un instrument foarte util. Pentru un exemplu detaliat, vezi Simularea eficientă a Circuit-urilor stabilizatoare cu primitivele Qiskit Aer.

Exemplu:

import numpy as np
from qiskit.circuit.library import efficient_su2

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

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_sampler import Sampler

n_qubits = 500  # <---- note this uses 500 qubits!
circuit = efficient_su2(n_qubits)
circuit.measure_all()

rng = np.random.default_rng(1234)
params = rng.choice(
    [0, np.pi / 2, np.pi, 3 * np.pi / 2],
    size=circuit.num_parameters,
)

# Tell Aer to use the stabilizer (Clifford) simulation method
aer_sim = AerSimulator(method="stabilizer")

pm = generate_preset_pass_manager(backend=aer_sim, optimization_level=1)
isa_qc = pm.run(qc)
sampler = Sampler(mode=aer_sim)
result = sampler.run([isa_qc]).result()

Testează local atenuarea erorilor

Cu Sampler și Estimator de pe partea clientului (introduse în qiskit-ibm-runtime v0.50.0), suprimarea și atenuarea erorilor au loc pe client, nu pe server. Ca rezultat, aceste opțiuni au acum efect în modul de testare locală, astfel încât poți experimenta cu diferite metode de atenuare a erorilor pe un Backend fals înainte de a consuma timp QPU.

notă

Cu primitivele vechi de pe partea serverului, setarea unei opțiuni precum resilience.measure_mitigation pe un simulator local nu avea niciun efect, deoarece procesarea atenuării rula doar pe server. Primitivele de pe partea clientului aplică această procesare local.

Considerații privind memoria și timpul de execuție suplimentar

Costul simulării zgomotoase locale crește exponențial cu numărul de Qubiți, iar majoritatea laptopurilor nu pot simula mai mult de aproximativ 32 de Qubiți. Deoarece metodele de suprimare și atenuare a erorilor rulează acum local, ele adaugă memorie și timp de execuție suplimentare peste simularea de bază. Pentru a menține testarea locală fezabilă, folosește una dintre următoarele variante:

• Un Backend fals de dimensiune mică (precum FakeManilaV2, folosit mai jos).

• Un simulator fără zgomot.

• Simularea Clifford, care scalează la un număr mare de Qubiți.

Exemplul următor activează atenuarea erorilor de măsurare cu Estimator și îl rulează pe un Backend fals. Opțiunea measure_mitigation = True este acum aplicată local circuitelor tale.

from qiskit.circuit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler import generate_preset_pass_manager

# Legacy server-side primitive before qiskit-ibm-runtime v0.50.0
# from qiskit_ibm_runtime import Estimator

# Client-side primitive introduced in qiskit-ibm-runtime v0.50.0
from qiskit_ibm_runtime.executor_estimator import Estimator
from qiskit_ibm_runtime.fake_provider import FakeManilaV2

# Bell Circuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)

observable = SparsePauliOp("ZZ")

# Transpile the circuit and observable for the fake backend
fake_manila = FakeManilaV2()
pm = generate_preset_pass_manager(backend=fake_manila, optimization_level=1)
isa_qc = pm.run(qc)
isa_observable = observable.apply_layout(isa_qc.layout)

# Run the Estimator job locally using FakeManilaV2
estimator = Estimator(mode=fake_manila)

# With the client-side Estimator, this option takes effect locally
estimator.options.resilience.measure_mitigation = True

result = estimator.run([(isa_qc, isa_observable)]).result()

Testarea locală comparată cu joburile dry-run

Local testing mode rulează pe propria ta mașină. Este o modalitate bună de a dezvolta și depana un program și de a vedea cum ar putea arăta rezultatul, dar nu îți poate spune cât ar taxa QPU-ul real sau dacă serviciul va accepta jobul.

Spre deosebire de testarea locală, un job dry-run rulează sarcina ta de lucru prin IBM Quantum Compute Service pe un dispozitiv mock, fără a folosi timp QPU, astfel încât poți vedea numărul de unități de resurse (RU) pe care jobul le-ar genera pe QPU-ul real. De asemenea, oferă la cerere validare din partea serviciului și programul de temporizare al circuitului.

	Fake backend (testare locală)	Dispozitiv mock (job dry-run)
Unde rulează	Local, pe mașina ta	În cloud, pe IBM Quantum Compute Service
Cont și instanță	Nu sunt necesare	Necesare (Flex, Premium sau On-Prem)
Rezultate	Simulare zgomotoasă folosind un model de zgomot instantaneu	Date randomizate cu schema așteptată. Nu este o simulare
Utilizare raportată	Niciuna	job.usage()
Validarea jobului	Limitată la ce verifică clientul	Realizată de Quantum Compute, la fel ca pentru un job real

Un flux de lucru obișnuit este să iterezi asupra circuitelor și rezultatelor cu un fake backend, apoi să rulezi un job dry-run ca ultimă verificare înainte de a rula pe QPU-ul real. Pentru o comparație completă, consultă Dispozitive mock comparate cu fake backends.

Pași următori

Recomandări

• Folosește clasa Neat pentru a analiza impactul zgomotului asupra unui workload Estimator.
• Consultă exemple detaliate cu Sampler.
• Consultă exemple detaliate cu Estimator.
• Exersează cu primitivele parcurgând lecția despre funcția cost din IBM Quantum Learning.
• Află cum să transpilezi local în secțiunea Transpile.
• Încearcă tutorialul Compararea setărilor Transpiler-ului.