Introducción al Transpiler con IA de Qiskit
Uso estimado: 5 minutos en IBM Heron (NOTA: Esto es solo una estimación. El tiempo de ejecución puede variar.)
Resultados de aprendizaje
Al completar este tutorial, los usuarios deberían comprender:
- Cómo usar el Transpiler con IA (
generate_ai_pass_manager) como reemplazo directo del transpiler estándar - Cómo el Transpiler con IA se compara con el transpiler predeterminado en términos de profundidad de dos qubits, conteo de gates y tiempo de transpilación
- Cómo usar mirror circuits para evaluar la calidad de la transpilación mediante ejecución en hardware real
Requisitos previos
Sugerimos que los usuarios estén familiarizados con los siguientes temas antes de comenzar este tutorial:
Antecedentes
El Transpiler con IA de Qiskit introduce pases de transpilación basados en aprendizaje automático que pueden producir circuits más cortos y más eficientes para el hardware que los métodos heurísticos tradicionales como SABRE. Los circuits más cortos acumulan menos ruido, lo que mejora directamente la calidad de los resultados en hardware cuántico real.
En este tutorial comparamos dos estrategias de transpilación:
| Estrategia | API |
|---|---|
| Predeterminada | generate_preset_pass_manager(optimization_level=3, ...) |
| IA | generate_ai_pass_manager(optimization_level=1, ai_optimization_level=3, ...) |
Medimos tres métricas para cada estrategia: profundidad de dos qubits, conteo total de gates y tiempo de transpilación.
Benchmarks del Transpiler con IA
En pruebas de benchmarking, el Transpiler con IA produjo consistentemente circuits menos profundos y de mayor calidad en comparación con el transpiler estándar de Qiskit. Para estas pruebas, utilizamos la estrategia predeterminada del gestor de pases de Qiskit, configurada con generate_preset_pass_manager. Si bien esta estrategia predeterminada suele ser efectiva, puede tener dificultades con circuits más grandes o más complejos. En contraste, los pases con IA lograron una reducción promedio del 24% en los conteos de gates de dos qubits y una reducción del 36% en la profundidad de los circuits para circuits grandes (100+ qubits) al transpilar a la topología heavy-hex del hardware de IBM Quantum®. Para más información sobre estos benchmarks, consulta este blog.
Este tutorial explora los beneficios clave de los pases de IA y cómo se comparan con los métodos tradicionales.
Requisitos
Antes de comenzar este tutorial, asegúrate de tener lo siguiente instalado:
- Qiskit SDK v2.0 o posterior, con soporte de visualización
- Qiskit Runtime (
pip install qiskit-ibm-runtime) v0.22 o posterior - Qiskit IBM Transpiler con modo local de IA (
pip install 'qiskit-ibm-transpiler[ai-local-mode]') - Qiskit Aer (
pip install qiskit-aer)
Configuración
# 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)
Ejemplo a pequeña escala con simulador
Paso 1: Mapear entradas clásicas a un problema cuántico
Generamos 20 circuits aleatorios con profundidad 4, donde el número de qubits va de seis a 25. Estos circuits servirán como casos de prueba para comparar las estrategias de transpilación.
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]
Paso 2: Optimizar el problema para la ejecución en hardware cuántico
Construimos el gestor de pases predeterminado (SABRE) para el Backend elegido. Ambas estrategias de transpilación apuntan al mapa de acoplamiento completo del Backend. La simulación local se mantiene manejable porque el paso de simulación usa remap_to_contiguous para reasignar cada circuit transpilado a solo sus qubits activos, de modo que Aer simule únicamente esos qubits en lugar del dispositivo completo.
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%
La tabla resumen muestra la media y la desviación estándar de cada métrica en los 20 circuits, junto con el porcentaje de mejora promedio del Transpiler con IA sobre el predeterminado. Los valores positivos indican que el Transpiler con IA produjo mejores resultados; los valores negativos indican que el predeterminado fue mejor.
Para este ejemplo a pequeña escala, el Transpiler con IA logra aproximadamente un 16% menos de profundidad de dos qubits en promedio, pero a costa de aproximadamente un 9% más de conteo de gates. Esto destaca un compromiso clave al elegir entre las dos estrategias: el Transpiler con IA prioriza la reducción de profundidad (menos capas secuenciales de gates de dos qubits), mientras que el transpiler predeterminado (SABRE) prioriza minimizar el conteo total de gates (menos inserciones de SWAP). Dependiendo de tu aplicación, una métrica puede importar más que la otra.
plot_metrics_and_pct(results_sim, "Small-Scale Random Circuits")
Profundidad de dos qubits: El Transpiler con IA generalmente produce circuits con menor profundidad de dos qubits. La profundidad es una de las métricas principales que el modelo de enrutamiento de IA está entrenado para optimizar, y la mejora es visible en la mayoría de los tamaños de circuits, aunque SABRE lo iguala o supera en circuits individuales.
Conteo de gates: Los resultados están muy igualados a esta escala, con SABRE manteniendo una ligera ventaja en general. La heurística de enrutamiento de SABRE está diseñada para minimizar el número de gates SWAP insertados, lo que reduce directamente el conteo de gates. A tamaños de circuits pequeños, la diferencia es modesta.
Tiempo de transpilación: El tiempo de ejecución de SABRE es casi constante independientemente del conteo de qubits, por lo que el tamaño del circuit tiene poco efecto en su tiempo de transpilación a esta escala. La lógica central de enrutamiento de SABRE está altamente optimizada (implementada en gran parte en Rust). El Transpiler con IA tarda notablemente más y escala con el tamaño del circuit, aunque los tiempos absolutos se mantienen razonables para uso interactivo.
Paso 3: Ejecutar usando primitivas de Qiskit
Para evaluar el impacto de la transpilación en la fidelidad del circuit, construye mirror circuits a partir del caso de 10 qubits y ejecútalos en el simulador Aer con un modelo de ruido simple. La salida esperada de un mirror circuit es siempre la cadena de bits de todos ceros, por lo que la probabilidad de medir demuestra qué tan bien cada estrategia de transpilación preserva la fidelidad.
# 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)
Ejecutamos ambos mirror circuits a través del simulador Aer con un modelo de ruido despolarizante simple. La probabilidad de supervivencia, definida como la fracción de shots que devuelven la cadena de bits de todos ceros, cuantifica cuánto ruido introduce cada estrategia de transpilación.
Paso 4: Post-procesar y devolver el resultado en el formato clásico deseado
Extraemos la probabilidad de medir la cadena de bits de todos ceros de ambas ejecuciones. Una mayor probabilidad de supervivencia indica mejor fidelidad, lo que significa que la transpilación introdujo menos ruido. El gráfico a continuación muestra el complemento, 1 - P(|0...0>), de modo que una barra más baja indica mejor fidelidad y las pequeñas diferencias en el error son más fáciles de ver.
# 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()
En este caso, el transpiler predeterminado produjo tanto un circuit más superficial como más pequeño para esta instancia particular de 10 qubits, por lo que su mayor fidelidad es lo esperado. Los resultados por circuit varían: como muestra la tabla resumen anterior, la ventaja del Transpiler con IA está en la menor profundidad de dos qubits en promedio, no en cada circuit individual. Qué estrategia produce mayor fidelidad depende de la magnitud de la diferencia en cada métrica, las características de ruido del hardware y la estructura del circuit. Bajo un modelo de ruido despolarizante uniforme, el conteo total de gates suele tener un impacto más directo en el error acumulado que la profundidad sola.
Ejemplo a gran escala con hardware real
Pasos 1-4
Aquí se reúnen todos estos detalles en un flujo de trabajo claro a mayor escala, que luego se ejecuta en hardware cuántico real.
El código a continuación genera 25 circuits aleatorios con profundidad 8, donde el número de qubits va de 26 a 50. Luego se transpilan estos circuits con ambas estrategias y se recopilan las mismas métricas. Después construimos mirror circuits a partir del caso de 26 qubits y los enviamos al Backend 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)
Análisis de resultados
Los resultados a gran escala refuerzan las tendencias observadas en el ejemplo a pequeña escala, ahora a una escala más exigente.
Profundidad de dos qubits: El Transpiler con IA sigue ofreciendo una profundidad de dos qubits notablemente menor en todo el rango de tamaños de circuits. La optimización de profundidad es uno de los objetivos principales en los que está entrenado el modelo de enrutamiento de IA, y la ventaja es más pronunciada con mayor cantidad de qubits, donde el problema de enrutamiento se vuelve más difícil para los métodos heurísticos.
Conteo de gates: El transpiler predeterminado (SABRE) produce consistentemente circuits con menos gates en todos los tamaños de circuits en este rango. La heurística de SABRE está diseñada específicamente para minimizar el conteo de gates, y a esta escala la ventaja es clara y uniforme.
Tiempo de transpilación: La brecha en el tiempo de transpilación se amplía a mayor escala. SABRE permanece casi constante, mientras que el tiempo de ejecución del Transpiler con IA crece más abruptamente. A pesar de esto, el tiempo de ejecución del Transpiler con IA sigue siendo práctico para la mayoría de los flujos de trabajo.
Fidelidad del mirror circuit: Ambos métodos producen probabilidades de supervivencia muy por debajo del 1% a esta escala, dejando poco margen de señal utilizable. Con conteos totales de gates alrededor de 10,000 y profundidades de dos qubits superiores a 1,000, el ruido despolarizante acumulado a lo largo del mirror circuit abruma la mayor parte de la señal. Esto destaca una limitación clave del enfoque del mirror circuit: aunque es simple y no requiere simulación clásica, no escala bien a circuits grandes o profundos, donde ambos métodos se acercan al umbral de ruido y la pequeña señal restante está dominada por el error acumulado.
Si bien estos resultados subrayan la efectividad del Transpiler con IA, es importante señalar sus limitaciones. El método de síntesis con IA actualmente solo está disponible para ciertos mapas de acoplamiento, lo que puede restringir su aplicabilidad más amplia. Esta restricción debe considerarse al evaluar su uso en diferentes escenarios.
Próximos pasos
Si encontraste este trabajo interesante, puede que te interese el siguiente material: