Úvod do Qiskit AI-powered transpiler
Odhadované využití: 5 minut na IBM Heron (POZNÁMKA: Jedná se pouze o odhad. Skutečná doba běhu se může lišit.)
Výsledky učení
Po absolvování tohoto tutoriálu by uživatelé měli rozumět:
- Jak používat AI-powered transpiler (
generate_ai_pass_manager) jako přímou náhradu za standardní transpiler - Jak se AI-powered transpiler porovnává s výchozím transpilerem z hlediska dvoququbitové hloubky, počtu Gate a doby transpilace
- Jak používat zrcadlové obvody k hodnocení kvality transpilace prostřednictvím spuštění na hardwaru
Předpoklady
Doporučujeme, aby uživatelé před absolvováním tohoto tutoriálu znali následující témata:
Pozadí
Qiskit AI-powered transpiler zavádí transpilační průchody založené na strojovém učení, které mohou produkovat kratší a hardwarově efektivnější obvody než tradiční heuristické metody jako SABRE. Kratší obvody akumulují méně šumu, což přímo zlepšuje kvalitu výsledků na skutečném kvantovém hardwaru.
V tomto tutoriálu porovnáváme dvě transpilační strategie:
| Strategie | API |
|---|---|
| Výchozí | generate_preset_pass_manager(optimization_level=3, ...) |
| AI | generate_ai_pass_manager(optimization_level=1, ai_optimization_level=3, ...) |
Pro každou strategii měříme tři metriky: dvoququbitovou hloubku Gate, celkový počet Gate a dobu transpilace.
Benchmarky AI-powered transpileru
V benchmarkingových testech AI-powered transpiler konzistentně produkoval mělčí a kvalitnější obvody ve srovnání se standardním Qiskit transpilerem. Pro tyto testy jsme použili výchozí strategii pass manageru Qiskitu nakonfigurovanou pomocí generate_preset_pass_manager. Ačkoli tato výchozí strategie je často účinná, může mít potíže s většími nebo složitějšími obvody. Naopak AI-powered průchody dosáhly průměrného snížení počtu dvoququbitových Gate o 24 % a snížení hloubky obvodu o 36 % pro velké obvody (100+ Qubitů) při transpilaci do heavy-hex topologie hardwaru IBM Quantum®. Více informací o těchto benchmarcích najdeš na tomto blogu.
Tento tutoriál prozkoumává klíčové výhody AI průchodů a jak se porovnávají s tradičními metodami.
Požadavky
Před zahájením tohoto tutoriálu se ujisti, že máš nainstalováno následující:
- Qiskit SDK v2.0 nebo novější, s podporou vizualizace
- Qiskit Runtime (
pip install qiskit-ibm-runtime) v0.22 nebo novější - Qiskit IBM Transpiler s lokálním AI režimem (
pip install 'qiskit-ibm-transpiler[ai-local-mode]') - Qiskit Aer (
pip install qiskit-aer)
Nastavení
# 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)
Příklad malého rozsahu se simulátorem
Krok 1: Mapování klasických vstupů na kvantový problém
Generujeme 20 náhodných obvodů s hloubkou 4, kde počet Qubitů se pohybuje od šesti do 25. Tyto obvody budou sloužit jako naše testovací případy pro porovnání transpilačních strategií.
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]
Krok 2: Optimalizace problému pro spuštění na kvantovém hardwaru
Sestavíme výchozí (SABRE) pass manager pro zvolený Backend. Obě transpilační strategie cílí na plnou coupling map Backendu. Lokální simulace je později zvládnutelná, protože simulační krok používá remap_to_contiguous k přeoznačení každého transpilovaného obvodu pouze na jeho aktivní Qubity, takže Aer simuluje jen ty Qubity místo celého zařízení.
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%
Souhrnná tabulka zobrazuje průměr a směrodatnou odchylku každé metriky napříč všemi 20 obvody spolu s průměrným procentuálním zlepšením AI-powered transpileru oproti výchozímu. Kladné hodnoty označují, že AI-powered transpiler dosáhl lepších výsledků; záporné hodnoty označují, že lepší byl výchozí transpiler.
Pro tento příklad malého rozsahu dosahuje AI-powered transpiler přibližně o 16 % nižší dvoququbitové hloubky v průměru, ale za cenu přibližně o 9 % vyššího počtu Gate. To zdůrazňuje klíčový kompromis při volbě mezi oběma strategiemi: AI-powered transpiler upřednostňuje snižování hloubky (méně sekvenčních vrstev dvoququbitových Gate), zatímco výchozí transpiler (SABRE) upřednostňuje minimalizaci celkového počtu Gate (méně SWAP vložení). V závislosti na tvé aplikaci může být jedna metrika důležitější než druhá.
plot_metrics_and_pct(results_sim, "Small-Scale Random Circuits")
Dvoququbitová hloubka: AI-powered transpiler obecně produkuje obvody s nižší dvoququbitovou hloubkou. Hloubka je jednou z primárních metrik, na jejichž optimalizaci je AI směrovací model trénován, a zlepšení je viditelné napříč většinou velikostí obvodů, i když SABRE ho na jednotlivých obvodech dokáže srovnat nebo překonat.
Počet Gate: Výsledky jsou na této škále blízko sebe, přičemž SABRE má celkově mírnou výhodu. Směrovací heuristika SABRE je navržena tak, aby minimalizovala počet vložených SWAP Gate, což přímo snižuje počet Gate. U malých obvodů je rozdíl skromný.
Doba transpilace: Doba běhu SABRE je téměř konstantní bez ohledu na počet Qubitů, takže velikost obvodu má na jeho dobu transpilace na této škále malý vliv. Klíčová logika směrování SABRE je vysoce optimalizována (z velké části implementována v jazyce Rust). AI-powered transpiler trvá znatelně déle a škáluje s velikostí obvodu, i když absolutní časy zůstávají přiměřené pro interaktivní použití.
Krok 3: Spuštění pomocí Qiskit primitiv
Pro hodnocení dopadu transpilace na věrnost obvodu sestav zrcadlové obvody z případu s 10 Qubity a spusť je na simulátoru Aer s jednoduchým modelem šumu. Očekávaný výstup zrcadlového obvodu je vždy bitový řetězec samých nul, takže pravděpodobnost měření ukazuje, jak dobře každá transpilační strategie zachovává věrnost.
# 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)
Oba zrcadlové obvody jsme spustili prostřednictvím simulátoru Aer s jednoduchým modelem depolarizujícího šumu. Pravděpodobnost přežití, definovaná jako podíl měření, která vrátí bitový řetězec samých nul, kvantifikuje, kolik šumu každá transpilační strategie zavádí.
Krok 4: Následné zpracování a vrácení výsledku v požadovaném klasickém formátu
Extrahujeme pravděpodobnost měření bitového řetězce samých nul z obou spuštění. Vyšší pravděpodobnost přežití označuje lepší věrnost, což znamená, že transpilace zavedla méně šumu. Graf níže zobrazuje doplněk, 1 - P(|0...0>), takže nižší sloupec označuje lepší věrnost a malé rozdíly v chybě jsou lépe viditelné.
# 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()
V tomto případě výchozí transpiler produkoval pro tento konkrétní 10-qubitový případ jak mělčí, tak menší obvod, takže jeho vyšší věrnost je očekávaná. Výsledky pro jednotlivé obvody se liší: jak ukazuje souhrnná tabulka výše, výhoda AI-powered transpileru spočívá v průměrně nižší dvoququbitové hloubce, nikoli v každém jednotlivém obvodu. Která strategie dosáhne vyšší věrnosti závisí na velikosti rozdílu v každé metrice, charakteristikách šumu hardwaru a struktuře obvodu. Při uniformním modelu depolarizujícího šumu má celkový počet Gate často přímější dopad na akumulovanou chybu než samotná hloubka.
Příklad velkého rozsahu na hardwaru
Kroky 1–4
Zde jsou všechny tyto detaily sestaveny do jasného pracovního postupu ve větším měřítku, který je pak spuštěn na skutečném kvantovém hardwaru.
Kód níže generuje 25 náhodných obvodů s hloubkou 8, kde počet Qubitů se pohybuje od 26 do 50. Tyto obvody jsou poté transpilovány oběma strategiemi a jsou shromažďovány stejné metriky. Poté sestavíme zrcadlové obvody z případu s 26 Qubity a odešleme je na skutečný Backend.
# -------------------------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)
Analýza výsledků
Výsledky ve velkém měřítku potvrzují trendy pozorované v příkladu malého rozsahu, nyní na náročnější škále.
Dvoququbitová hloubka: AI-powered transpiler nadále dosahuje znatelně nižší dvoququbitové hloubky napříč celým rozsahem velikostí obvodů. Optimalizace hloubky je jedním z primárních cílů, na které je AI směrovací model trénován, a výhoda je výraznější při větším počtu Qubitů, kde je směrovací problém pro heuristické metody obtížnější.
Počet Gate: Výchozí transpiler (SABRE) konzistentně produkuje obvody s méně Gate napříč všemi velikostmi obvodů v tomto rozsahu. Heuristika SABRE je speciálně navržena tak, aby minimalizovala počet Gate, a na této škále je výhoda jasná a rovnoměrná.
Doba transpilace: Rozdíl v době transpilace se ve větším měřítku rozšiřuje. SABRE zůstává téměř konstantní, zatímco doba běhu AI-powered transpileru roste strmějším tempem. Navzdory tomu zůstává doba běhu AI-powered transpileru pro většinu pracovních postupů praktická.
Věrnost zrcadlového obvodu: Obě metody produkují pravděpodobnosti přežití výrazně pod 1 % v tomto měřítku, přičemž zbývá jen málo použitelného signálu. S celkovým počtem Gate kolem 10 000 a dvoququbitovými hloubkami přesahujícími 1 000 zahltí depolarizující šum akumulovaný přes zrcadlový obvod většinu signálu. To poukazuje na klíčové omezení přístupu se zrcadlovými obvody: ačkoli je jednoduchý a nevyžaduje klasickou simulaci, dobře se nešká na velké nebo hluboké obvody, kde jsou obě metody posunuty blízko šumovému prahu a malý přežívající signál je dominován akumulovanou chybou.
Ačkoli tyto výsledky podtrhují efektivitu AI-powered transpileru, je důležité poznamenat jeho omezení. Metoda AI syntézy je v současné době dostupná pouze pro určité coupling mapy, což může omezovat její širší použitelnost. Toto omezení je třeba vzít v úvahu při hodnocení jejího použití v různých scénářích.
Další kroky
Pokud tě tato práce zaujala, možná tě budou zajímat i následující materiály: