Introducere în Transpilerul AI Qiskit
Estimare de utilizare: 5 minute pe IBM Heron (NOTĂ: Aceasta este doar o estimare. Timpul tău de execuție poate varia.)
Rezultate de învățare
După parcurgerea acestui tutorial, utilizatorii ar trebui să înțeleagă:
- Cum să utilizeze transpilerul AI (
generate_ai_pass_manager) ca înlocuitor direct al transpilerului standard - Cum se compară transpilerul AI cu transpilerul implicit în ceea ce privește adâncimea cu doi qubiți, numărul de porți și timpul de transpilare
- Cum să utilizeze circuitele oglindă pentru a evalua calitatea transpilării prin execuție pe hardware
Condiții prealabile
Sugerăm ca utilizatorii să fie familiarizați cu următoarele subiecte înainte de a parcurge acest tutorial:
Context
Transpilerul AI Qiskit introduce pase de transpilare bazate pe învățare automată care pot produce circuite mai scurte și mai eficiente din punct de vedere hardware decât metodele euristice tradiționale, precum SABRE. Circuitele mai scurte acumulează mai puțin zgomot, ceea ce îmbunătățește direct calitatea rezultatelor pe hardware-ul cuantic real.
În acest tutorial comparăm două strategii de transpilare:
| Strategie | API |
|---|---|
| Implicit | generate_preset_pass_manager(optimization_level=3, ...) |
| AI | generate_ai_pass_manager(optimization_level=1, ai_optimization_level=3, ...) |
Măsurăm trei metrici pentru fiecare strategie: adâncimea porților cu doi qubiți, numărul total de porți și durata transpilării.
Benchmarkuri ale transpilerului AI
În testele de benchmarking, transpilerul AI a produs în mod constant circuite mai puțin adânci și de calitate superioară față de transpilerul standard Qiskit. Pentru aceste teste am utilizat strategia implicită a managerului de pase din Qiskit, configurată cu generate_preset_pass_manager. Deși această strategie implicită este adesea eficientă, poate întâmpina dificultăți cu circuitele mai mari sau mai complexe. Prin contrast, pasele bazate pe AI au obținut o reducere medie de 24% a numărului de porți cu doi qubiți și o reducere de 36% a adâncimii circuitelor pentru circuitele mari (100+ qubiți) la transpilarea către topologia heavy-hex a hardware-ului IBM Quantum®. Pentru mai multe informații despre aceste benchmarkuri, consultați acest blog.
Acest tutorial explorează beneficiile cheie ale paselor AI și modul în care acestea se compară cu metodele tradiționale.
Cerințe
Înainte de a începe acest tutorial, asigură-te că ai instalate următoarele:
- Qiskit SDK v2.0 sau o versiune mai recentă, cu suport pentru vizualizare
- Qiskit Runtime (
pip install qiskit-ibm-runtime) v0.22 sau o versiune mai recentă - Qiskit IBM Transpiler cu modul AI local (
pip install 'qiskit-ibm-transpiler[ai-local-mode]') - Qiskit Aer (
pip install qiskit-aer)
Configurare
# Added by doQumentation — required packages for this notebook
!pip install -q matplotlib qiskit qiskit-aer qiskit-ibm-runtime qiskit-ibm-transpiler
from qiskit import QuantumCircuit
from qiskit.circuit.random import random_circuit
from qiskit.transpiler import generate_preset_pass_manager
from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2
from qiskit_ibm_transpiler import generate_ai_pass_manager
from qiskit_aer import AerSimulator
from qiskit_aer.noise import NoiseModel, depolarizing_error
import matplotlib.pyplot as plt
from statistics import mean, stdev
import time
import logging
seed = 42
def transpile_with_metrics(pass_manager, circuit):
"""Transpile a circuit and return the result along with key metrics."""
start = time.time()
qc_out = pass_manager.run(circuit)
elapsed = time.time() - start
depth_2q = qc_out.depth(lambda x: x.operation.num_qubits == 2)
gate_count = qc_out.size()
return qc_out, {
"depth_2q": depth_2q,
"gate_count": gate_count,
"time_s": round(elapsed, 3),
}
def remap_to_contiguous(tqc):
"""Remap a transpiled circuit to use contiguous qubit indices.
Transpiled circuits target specific physical qubits (e.g., qubit 45, 67)
on a large backend. This remaps them to 0, 1, 2, ... so Aer only
simulates the active qubits."""
active = sorted(
{tqc.find_bit(q).index for inst in tqc.data for q in inst.qubits}
)
qubit_map = {old: new for new, old in enumerate(active)}
new_qc = QuantumCircuit(len(active))
for inst in tqc.data:
old_indices = [tqc.find_bit(q).index for q in inst.qubits]
new_qc.append(inst.operation, [qubit_map[i] for i in old_indices])
return new_qc
def build_mirror_circuit(tqc, simulate=True):
"""Build a mirror circuit: U followed by U-dagger, with measurements.
The expected output is always |0...0>, so measuring the survival
probability reveals how much noise each transpilation strategy adds.
Args:
tqc: A transpiled circuit.
simulate: If True (default), remap to contiguous qubits so Aer
only simulates the active qubits. If False, keep the full
physical layout for hardware execution."""
if simulate:
tqc = remap_to_contiguous(tqc)
mirror = tqc.compose(tqc.inverse())
mirror.measure_all()
return mirror
def print_summary(results):
"""Print a summary of each metric as mean +/- stdev across all circuits,
along with the mean percentage improvement of AI over Default."""
metrics = [
("Depth 2Q", "Depth 2Q (Default)", "Depth 2Q (AI)"),
("Gate Count", "Gate Count (Default)", "Gate Count (AI)"),
("Time (s)", "Time (Default)", "Time (AI)"),
]
header = (
f"{'Metric':<12}{'Default (mean +/- std)':>24}"
f"{'AI (mean +/- std)':>22}{'AI % improvement':>22}"
)
print(header)
print("-" * len(header))
for label, col_def, col_ai in metrics:
defaults = [r[col_def] for r in results]
ais = [r[col_ai] for r in results]
pct = [(d - a) / d * 100 for d, a in zip(defaults, ais)]
default_str = f"{mean(defaults):.1f} +/- {stdev(defaults):.1f}"
ai_str = f"{mean(ais):.1f} +/- {stdev(ais):.1f}"
pct_str = f"{mean(pct):+.1f}% +/- {stdev(pct):.1f}%"
print(f"{label:<12}{default_str:>24}{ai_str:>22}{pct_str:>22}")
def plot_metrics_and_pct(results, title_prefix):
"""Plot metric comparisons and percentage improvement of AI over Default."""
qubits = [r["Qubits"] for r in results]
metrics = [
("Depth 2Q (Default)", "Depth 2Q (AI)", "Two-Qubit Depth"),
("Gate Count (Default)", "Gate Count (AI)", "Gate Count"),
("Time (Default)", "Time (AI)", "Transpilation Time"),
]
# Row 1: raw metric comparison
fig, axs = plt.subplots(1, 3, figsize=(21, 5))
fig.suptitle(
f"{title_prefix}: Metric Comparison",
fontsize=15,
fontweight="bold",
y=1.02,
)
for ax, (col_def, col_ai, label) in zip(axs, metrics):
ax.plot(qubits, [r[col_def] for r in results], "o-", label="Default")
ax.plot(qubits, [r[col_ai] for r in results], "s-", label="AI")
ax.set_title(label)
ax.set_xlabel("Number of Qubits")
ax.set_ylabel(label)
ax.legend()
plt.tight_layout()
plt.show()
# Row 2: percentage improvement
fig, axs = plt.subplots(1, 3, figsize=(21, 5))
fig.suptitle(
f"{title_prefix}: % Improvement of AI over Default",
fontsize=15,
fontweight="bold",
y=1.02,
)
for ax, (col_def, col_ai, label) in zip(axs, metrics):
pct = [(r[col_def] - r[col_ai]) / r[col_def] * 100 for r in results]
ax.axhline(
0, color="#1f77b4", linewidth=2, label="Default (baseline)"
)
ax.plot(qubits, pct, "s-", color="#ff7f0e", label="AI")
ax.fill_between(qubits, 0, pct, alpha=0.15, color="#ff7f0e")
ax.set_title(label)
ax.set_xlabel("Number of Qubits")
ax.set_ylabel("% Improvement")
ax.legend()
plt.tight_layout()
plt.show()
# Suppress verbose AI-powered transpiler logs
logging.getLogger(
"qiskit_ibm_transpiler.wrappers.ai_local_synthesis"
).setLevel(logging.WARNING)
Exemplu la scară mică cu simulator
Pasul 1: Mapează intrările clasice la o problemă cuantică
Generăm 20 de circuite aleatoare cu adâncimea 4, unde numărul de qubiți variază de la șase la 25. Aceste circuite vor servi drept cazuri de test pentru compararea strategiilor de transpilare.
num_circuits_sim = 20
depth_sim = 4
qubit_range_sim = list(range(6, 26))
circuits_sim = [
# We have only two qubit gates, as those test how well the transpiler can optimize the circuit.
random_circuit(
num_qubits=n,
depth=depth_sim,
max_operands=2,
num_operand_distribution={2: 1},
seed=seed + i,
)
for i, n in enumerate(qubit_range_sim)
]
print(
f"Created {len(circuits_sim)} circuits with qubit counts: {qubit_range_sim}"
)
circuits_sim[0].draw(output="mpl", fold=-1)
Created 20 circuits with qubit counts: [6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]
Pasul 2: Optimizează problema pentru execuția pe hardware cuantic
Construim managerul de pase implicit (SABRE) pentru Backend-ul ales. Ambele strategii de transpilare vizează harta de cuplare completă a Backend-ului. Simularea locală rămâne tractabilă deoarece pasul de simulare utilizează remap_to_contiguous pentru a reeticheta fiecare circuit transpilat pe qubiții săi activi, astfel Aer simulează doar acei qubiți în loc de întregul dispozitiv.
service = QiskitRuntimeService()
backend = service.least_busy(
min_num_qubits=100, operational=True, simulator=False
)
pm_default_sim = generate_preset_pass_manager(
optimization_level=3,
backend=backend,
seed_transpiler=seed,
)
results_sim = []
for i, qc in enumerate(circuits_sim):
n = qubit_range_sim[i]
qc_default, m_default = transpile_with_metrics(pm_default_sim, qc)
# Create a fresh AI pass manager each iteration to avoid stale layout state
pm_ai = generate_ai_pass_manager(
optimization_level=1,
ai_optimization_level=3,
backend=backend,
)
qc_ai, m_ai = transpile_with_metrics(pm_ai, qc)
results_sim.append(
{
"Qubits": n,
"Depth 2Q (Default)": m_default["depth_2q"],
"Depth 2Q (AI)": m_ai["depth_2q"],
"Gate Count (Default)": m_default["gate_count"],
"Gate Count (AI)": m_ai["gate_count"],
"Time (Default)": m_default["time_s"],
"Time (AI)": m_ai["time_s"],
}
)
print_summary(results_sim)
Fetching 4 files: 0%| | 0/4 [00:00<?, ?it/s]
Metric Default (mean +/- std) AI (mean +/- std) AI % improvement
--------------------------------------------------------------------------------
Depth 2Q 33.0 +/- 12.9 26.4 +/- 8.0 +15.8% +/- 17.6%
Gate Count 522.0 +/- 266.0 560.5 +/- 279.1 -9.0% +/- 9.0%
Time (s) 0.0 +/- 0.0 0.2 +/- 0.1 -893.6% +/- 362.9%
Tabelul rezumat arată media și deviația standard a fiecărei metrici pentru toate cele 20 de circuite, împreună cu îmbunătățirea procentuală medie a transpilerului AI față de cel implicit. Valorile pozitive indică faptul că transpilerul AI a produs rezultate mai bune; valorile negative indică faptul că cel implicit a fost mai bun.
Pentru acest exemplu la scară mică, transpilerul AI obține o adâncime cu doi qubiți cu aproximativ 16% mai mică în medie, dar cu prețul unui număr de porți cu aproximativ 9% mai mare. Aceasta evidențiază un compromis cheie între cele două strategii: transpilerul AI prioritizează reducerea adâncimii (mai puține straturi secvențiale de porți cu doi qubiți), în timp ce transpilerul implicit (SABRE) prioritizează minimizarea numărului total de porți (mai puține inserții de SWAP). În funcție de aplicație, o metrică poate conta mai mult decât cealaltă.
plot_metrics_and_pct(results_sim, "Small-Scale Random Circuits")
Adâncimea cu doi qubiți: Transpilerul AI produce în general circuite cu adâncime mai mică a porților cu doi qubiți. Adâncimea este una dintre metricile principale pentru care modelul de rutare AI este antrenat să optimizeze, iar îmbunătățirea este vizibilă pentru majoritatea dimensiunilor de circuit, deși SABRE îl egalează sau îl depășește pe circuite individuale.
Numărul de porți: Rezultatele sunt strâns echilibrate la această scară, cu SABRE deținând un ușor avantaj global. Euristica de rutare a SABRE este concepută să minimizeze numărul de porți SWAP inserate, ceea ce reduce direct numărul de porți. La dimensiuni mici de circuit, diferența este modestă.
Timpul de transpilare: Durata SABRE este aproape constantă indiferent de numărul de qubiți, deci dimensiunea circuitului are puțin efect asupra timpului de transpilare la această scară. Logica de rutare de bază a SABRE este extrem de optimizată (implementată în mare parte în Rust). Transpilerul AI durează considerabil mai mult și se scalează cu dimensiunea circuitului, deși timpii absoluți rămân rezonabili pentru utilizare interactivă.
Pasul 3: Execută folosind primitivele Qiskit
Pentru a evalua impactul transpilării asupra fidelității circuitului, construim circuite oglindă din cazul cu 10 qubiți și le rulăm pe simulatorul Aer cu un model simplu de zgomot. Rezultatul așteptat al unui circuit oglindă este întotdeauna șirul de biți de toate zerouri, deci probabilitatea de a măsura demonstrează cât de bine fiecare strategie de transpilare păstrează fidelitatea.
# Use the 10-qubit circuit (index where qubits == 10)
idx_10q = qubit_range_sim.index(10)
qc_10q = circuits_sim[idx_10q]
qc_default_10q, _ = transpile_with_metrics(pm_default_sim, qc_10q)
pm_ai = generate_ai_pass_manager(
optimization_level=1,
ai_optimization_level=3,
backend=backend,
)
qc_ai_10q, _ = transpile_with_metrics(pm_ai, qc_10q)
tqc_methods = {
"Default": qc_default_10q,
"AI": qc_ai_10q,
}
print(
f"Default: depth {qc_default_10q.depth()}, gates {qc_default_10q.size()}"
)
print(f"AI: depth {qc_ai_10q.depth()}, gates {qc_ai_10q.size()}")
Default: depth 84, gates 280
AI: depth 91, gates 343
# Build a simple depolarizing noise model
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(
depolarizing_error(0.001, 1),
["sx", "x", "rz"], # ~0.1% per 1Q gate
)
noise_model.add_all_qubit_quantum_error(
depolarizing_error(0.01, 2),
["cx", "ecr"], # ~1% per 2Q gate
)
aer_sim = AerSimulator(noise_model=noise_model)
shots = 10000
survival_probs = {}
for method, tqc in tqc_methods.items():
mirror = build_mirror_circuit(tqc, simulate=True)
sampler = SamplerV2(mode=aer_sim)
job = sampler.run([mirror], shots=shots)
counts = job.result()[0].data.meas.get_counts()
all_zeros = "0" * mirror.num_qubits
survival = counts.get(all_zeros, 0) / shots
survival_probs[method] = survival
print(
f"{method:8s} P(|00...0>) = {survival:.4f} ({counts.get(all_zeros, 0)}/{shots})"
)
Default P(|00...0>) = 0.8460 (8460/10000)
AI P(|00...0>) = 0.8121 (8121/10000)
Am rulat ambele circuite oglindă prin simulatorul Aer cu un model simplu de zgomot depolarizant. Probabilitatea de supraviețuire, definită ca fracțiunea de măsurători care returnează șirul de toate zerouri, cuantifică cât de mult zgomot introduce fiecare strategie de transpilare.
Pasul 4: Post-procesează și returnează rezultatul în formatul clasic dorit
Extragem probabilitatea de a măsura șirul de toate zerouri din ambele rulări. O probabilitate de supraviețuire mai mare indică o fidelitate mai bună, ceea ce înseamnă că transpilarea a introdus mai puțin zgomot. Graficul de mai jos arată complementul, 1 - P(|0...0>), astfel încât o bară mai mică indică o fidelitate mai bună, iar micile diferențe de eroare sunt mai ușor de observat.
# Plot 1 - P(|0...0>), the probability of an erroneous (non-zero) outcome.
# A lower bar means the transpilation introduced less noise.
error_probs = {method: 1 - p for method, p in survival_probs.items()}
fig, ax = plt.subplots(figsize=(6, 4))
ax.bar(
error_probs.keys(),
error_probs.values(),
color=["steelblue", "coral"],
)
ax.set_ylabel("1 - P(|0...0>)")
ax.set_title("Mirror Circuit Error (10-qubit, Aer Simulator)")
ax.set_ylim(0, 1)
plt.tight_layout()
plt.show()
În acest caz, transpilerul implicit a produs atât un circuit mai puțin adânc, cât și mai mic pentru această instanță particulară cu 10 qubiți, deci fidelitatea sa mai ridicată este de așteptat. Rezultatele per circuit variază: după cum arată tabelul rezumat de mai sus, avantajul transpilerului AI constă în adâncimea medie mai mică cu doi qubiți, nu pe fiecare circuit individual. Strategia care produce o fidelitate mai mare depinde de magnitudinea diferenței fiecărei metrici, caracteristicile de zgomot ale hardware-ului și structura circuitului. Sub un model uniform de zgomot depolarizant, numărul total de porți are adesea un impact mai direct asupra erorii acumulate decât adâncimea singură.
Exemplu la scară mare pe hardware
Pașii 1-4
Aici toate aceste detalii sunt reunite într-un flux de lucru clar la o scară mai mare, care este apoi rulat pe hardware cuantic real.
Codul de mai jos generează 25 de circuite aleatoare cu adâncimea 8, unde numărul de qubiți variază de la 26 la 50. Aceste circuite sunt apoi transpilate cu ambele strategii și aceleași metrici sunt colectate. Apoi construim circuite oglindă din cazul cu 26 de qubiți și le transmitem Backend-ului real.
# -------------------------Step 1-------------------------
num_circuits_hw = 25
depth_hw = 8
qubit_range_hw = list(range(26, 51))
circuits_hw = [
# We have only two qubit gates, as those test how well the transpiler can optimize the circuit.
random_circuit(
num_qubits=n,
depth=depth_hw,
max_operands=2,
num_operand_distribution={2: 1},
seed=seed + i,
)
for i, n in enumerate(qubit_range_hw)
]
print(
f"Created {len(circuits_hw)} circuits with qubit counts: {qubit_range_hw}"
)
Created 25 circuits with qubit counts: [26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50]
# -------------------------Step 2-------------------------
pm_default = generate_preset_pass_manager(
optimization_level=3,
backend=backend,
seed_transpiler=seed,
)
results_hw = []
for i, qc in enumerate(circuits_hw):
n = qubit_range_hw[i]
qc_default, m_default = transpile_with_metrics(pm_default, qc)
# Create a fresh AI pass manager each iteration to avoid stale layout state
pm_ai = generate_ai_pass_manager(
optimization_level=1,
ai_optimization_level=3,
backend=backend,
)
qc_ai, m_ai = transpile_with_metrics(pm_ai, qc)
results_hw.append(
{
"Qubits": n,
"Depth 2Q (Default)": m_default["depth_2q"],
"Depth 2Q (AI)": m_ai["depth_2q"],
"Gate Count (Default)": m_default["gate_count"],
"Gate Count (AI)": m_ai["gate_count"],
"Time (Default)": m_default["time_s"],
"Time (AI)": m_ai["time_s"],
}
)
print_summary(results_hw)
Metric Default (mean +/- std) AI (mean +/- std) AI % improvement
--------------------------------------------------------------------------------
Depth 2Q 217.4 +/- 50.4 191.0 +/- 35.6 +10.9% +/- 10.7%
Gate Count 4513.3 +/- 1394.3 5227.1 +/- 1536.4 -16.4% +/- 5.8%
Time (s) 0.1 +/- 0.0 3.5 +/- 1.5 -3588.2% +/- 643.6%
plot_metrics_and_pct(results_hw, "Large-Scale Random Circuits")
# -------------------------Step 3-------------------------
# Build mirror circuits from the 26-qubit case
idx_26q = qubit_range_hw.index(26)
qc_26q = circuits_hw[idx_26q]
qc_default_26q, _ = transpile_with_metrics(pm_default, qc_26q)
pm_ai = generate_ai_pass_manager(
optimization_level=1,
ai_optimization_level=3,
backend=backend,
)
qc_ai_26q, _ = transpile_with_metrics(pm_ai, qc_26q)
mirror_default_hw = build_mirror_circuit(qc_default_26q, simulate=False)
mirror_ai_hw = build_mirror_circuit(qc_ai_26q, simulate=False)
# Re-transpile to basis gates (the inverse can introduce gates like sxdg)
pm_basis = generate_preset_pass_manager(
optimization_level=0,
backend=backend,
)
mirror_default_hw = pm_basis.run(mirror_default_hw)
mirror_ai_hw = pm_basis.run(mirror_ai_hw)
print(
f"Mirror circuit (Default): depth {mirror_default_hw.depth()}, gates {mirror_default_hw.size()}"
)
print(
f"Mirror circuit (AI): depth {mirror_ai_hw.depth()}, gates {mirror_ai_hw.size()}"
)
# Submit to real hardware
sampler_hw = SamplerV2(mode=backend)
sampler_hw.options.environment.job_tags = ["TUT_AITI"]
shots_hw = 500000
job_hw = sampler_hw.run([mirror_default_hw, mirror_ai_hw], shots=shots_hw)
print(f"Job submitted: {job_hw.job_id()}")
Mirror circuit (Default): depth 1577, gates 9672
Mirror circuit (AI): depth 1235, gates 11092
Job submitted: d8gt7vm6983c73dqbg0g
# -------------------------Step 4-------------------------
result_hw = job_hw.result()
survival_probs_hw = {}
for i, method in enumerate(["Default", "AI"]):
counts = result_hw[i].data.meas.get_counts()
mirror = [mirror_default_hw, mirror_ai_hw][i]
all_zeros = "0" * mirror.num_qubits
survival = counts.get(all_zeros, 0) / shots_hw
survival_probs_hw[method] = survival
print(
f"{method:8s} P(|00...0>) = {survival:.4f} ({counts.get(all_zeros, 0)}/{shots_hw})"
)
# Plot 1 - P(|0...0>), the probability of an erroneous (non-zero) outcome.
# A lower bar means the transpilation introduced less noise.
error_probs_hw = {method: 1 - p for method, p in survival_probs_hw.items()}
fig, ax = plt.subplots(figsize=(6, 4))
ax.bar(
error_probs_hw.keys(),
error_probs_hw.values(),
color=["steelblue", "coral"],
)
ax.set_ylabel("1 - P(|0...0>)")
ax.set_title(f"Mirror Circuit Error (26-qubit, {backend.name})")
ax.set_ylim(0, 1)
plt.tight_layout()
plt.show()
Default P(|00...0>) = 0.0005 (239/500000)
AI P(|00...0>) = 0.0050 (2516/500000)
Analiza rezultatelor
Rezultatele la scară mare confirmă tendințele observate în exemplul la scară mică, acum la o scară mai solicitantă.
Adâncimea cu doi qubiți: Transpilerul AI continuă să ofere o adâncime cu doi qubiți vizibil mai mică pe întreaga gamă de dimensiuni de circuit. Optimizarea adâncimii este unul dintre obiectivele principale pentru care modelul de rutare AI este antrenat, iar avantajul este mai pronunțat la numere mai mari de qubiți, unde problema de rutare devine mai dificilă pentru metodele euristice.
Numărul de porți: Transpilerul implicit (SABRE) produce în mod constant circuite cu mai puține porți pentru toate dimensiunile de circuit din acest interval. Euristica SABRE este special concepută pentru a minimiza numărul de porți, iar la această scară avantajul este clar și uniform.
Timpul de transpilare: Diferența în timpul de transpilare se lărgește la scări mai mari. SABRE rămâne aproape constant, în timp ce durata de execuție a transpilerului AI crește mai abrupt. Cu toate acestea, durata transpilerului AI rămâne practică pentru majoritatea fluxurilor de lucru.
Fidelitatea circuitului oglindă: Ambele metode produc probabilități de supraviețuire mult sub 1% la această scară, lăsând puțin semnal utilizabil. Cu numărul total de porți în jurul valorii de 10.000 și adâncimi cu doi qubiți depășind 1.000, zgomotul depolarizant acumulat pe tot circuitul oglindă copleșește cea mai mare parte a semnalului. Aceasta evidențiază o limitare cheie a abordării cu circuit oglindă: deși este simplă și nu necesită simulare clasică, nu se scalează bine la circuite mari sau adânci, unde ambele metode sunt împinse aproape de nivelul de zgomot, iar micul semnal rămas este dominat de eroarea acumulată.
Deși aceste rezultate subliniază eficacitatea transpilerului AI, este important să se noteze limitările sale. Metoda de sinteză AI este disponibilă în prezent doar pentru anumite hărți de cuplare, ceea ce îi poate restricționa aplicabilitatea mai largă. Această constrângere trebuie avută în vedere la evaluarea utilizării sale în scenarii diferite.
Pași următori
Dacă ți s-a părut interesant acest material, ar putea să te intereseze și: