Introdução ao transpilador com IA do Qiskit
Estimativa de uso: 5 minutos no IBM Heron (NOTA: Esta é apenas uma estimativa. O tempo de execução pode variar.)
Resultados de aprendizagem
Após concluir este tutorial, os usuários devem compreender:
- Como usar o transpilador com IA (
generate_ai_pass_manager) como substituto imediato para o transpilador padrão - Como o transpilador com IA se compara ao transpilador padrão em termos de profundidade de dois qubits, contagem de portas e tempo de transpilação
- Como usar mirror circuits para avaliar a qualidade da transpilação por meio de execução em hardware
Pré-requisitos
Sugerimos que os usuários estejam familiarizados com os seguintes tópicos antes de realizar este tutorial:
Contexto
O transpilador com IA do Qiskit introduz passes de transpilação baseados em aprendizado de máquina que podem produzir circuitos mais curtos e mais eficientes para o hardware do que os métodos heurísticos tradicionais, como o SABRE. Circuitos mais curtos acumulam menos ruído, o que melhora diretamente a qualidade dos resultados em hardware quântico real.
Neste tutorial, comparamos duas estratégias de transpilação:
| Estratégia | API |
|---|---|
| Padrão | generate_preset_pass_manager(optimization_level=3, ...) |
| IA | generate_ai_pass_manager(optimization_level=1, ai_optimization_level=3, ...) |
Medimos três métricas para cada estratégia: profundidade de portas de dois qubits, contagem total de portas e tempo de transpilação.
Benchmarks do transpilador com IA
Em testes de benchmarking, o transpilador com IA consistentemente produziu circuitos mais rasos e de maior qualidade em comparação com o transpilador padrão do Qiskit. Para esses testes, usamos a estratégia do gerenciador de passes padrão do Qiskit, configurado com generate_preset_pass_manager. Embora essa estratégia padrão seja frequentemente eficaz, ela pode ter dificuldades com circuitos maiores ou mais complexos. Em contraste, os passes com IA alcançaram uma redução média de 24% nas contagens de portas de dois qubits e uma redução de 36% na profundidade do circuito para circuitos grandes (100+ qubits) ao transpilar para a topologia heavy-hex do hardware IBM Quantum®. Para mais informações sobre esses benchmarks, consulte este blog.
Este tutorial explora os principais benefícios dos passes de IA e como eles se comparam aos métodos tradicionais.
Requisitos
Antes de iniciar este tutorial, certifique-se de ter o seguinte instalado:
- Qiskit SDK v2.0 ou posterior, com suporte a visualização
- Qiskit Runtime (
pip install qiskit-ibm-runtime) v0.22 ou posterior - Qiskit IBM Transpiler com modo local de IA (
pip install 'qiskit-ibm-transpiler[ai-local-mode]') - Qiskit Aer (
pip install qiskit-aer)
Configuração
# 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)
Exemplo em simulador de pequena escala
Passo 1: Mapear entradas clássicas para um problema quântico
Geramos 20 circuitos aleatórios com profundidade 4, onde o número de qubits varia de seis a 25. Esses circuitos servirão como casos de teste para comparar as estratégias de transpilação.
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]
Passo 2: Otimizar o problema para execução em hardware quântico
Construímos o gerenciador de passes padrão (SABRE) para o backend escolhido. Ambas as estratégias de transpilação têm como alvo o mapa de acoplamento completo do backend. A simulação local posterior permanece viável porque a etapa de simulação usa remap_to_contiguous para remapear cada circuito transpilado apenas para seus qubits ativos, de modo que o Aer simula apenas esses qubits em vez do dispositivo inteiro.
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%
A tabela de resumo mostra a média e o desvio padrão de cada métrica em todos os 20 circuitos, juntamente com a melhoria percentual média do transpilador com IA em relação ao padrão. Valores positivos indicam que o transpilador com IA produziu melhores resultados; valores negativos indicam que o padrão foi melhor.
Para este exemplo de pequena escala, o transpilador com IA alcança uma profundidade de dois qubits cerca de 16% menor em média, mas ao custo de uma contagem de portas cerca de 9% maior. Isso evidencia um compromisso importante ao escolher entre as duas estratégias: o transpilador com IA prioriza a redução de profundidade (menos camadas sequenciais de portas de dois qubits), enquanto o transpilador padrão (SABRE) prioriza a minimização da contagem total de portas (menos inserções de SWAP). Dependendo da sua aplicação, uma métrica pode importar mais do que a outra.
plot_metrics_and_pct(results_sim, "Small-Scale Random Circuits")
Profundidade de dois qubits: O transpilador com IA geralmente produz circuitos com menor profundidade de dois qubits. A profundidade é uma das principais métricas para as quais o modelo de roteamento com IA é treinado para otimizar, e a melhoria é visível na maioria dos tamanhos de circuito, embora o SABRE consiga igualar ou superá-lo em circuitos individuais.
Contagem de portas: Os resultados são bastante próximos nessa escala, com o SABRE mantendo uma ligeira vantagem geral. A heurística de roteamento do SABRE é projetada para minimizar o número de portas SWAP inseridas, o que reduz diretamente a contagem de portas. Em tamanhos de circuito pequenos, a diferença é modesta.
Tempo de transpilação: O tempo de execução do SABRE é quase constante independentemente da contagem de qubits, portanto o tamanho do circuito tem pouco efeito no seu tempo de transpilação nessa escala. A lógica central de roteamento do SABRE é altamente otimizada (em grande parte implementada em Rust). O transpilador com IA demora visivelmente mais e escala com o tamanho do circuito, embora os tempos absolutos permaneçam razoáveis para uso interativo.
Passo 3: Executar usando primitivos Qiskit
Para avaliar o impacto da transpilação na fidelidade do circuito, construímos mirror circuits a partir do caso de 10 qubits e os executamos no simulador Aer com um modelo de ruído simples. A saída esperada de um mirror circuit é sempre o bitstring de todos os zeros, portanto a probabilidade de medir demonstra como cada estratégia de transpilação preserva a fidelidade.
# 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)
Executamos ambos os mirror circuits pelo simulador Aer com um modelo de ruído depolarizante simples. A probabilidade de sobrevivência, definida como a fração de shots que retornam o bitstring de todos os zeros, quantifica quanto ruído cada estratégia de transpilação introduz.
Passo 4: Pós-processar e retornar resultado no formato clássico desejado
Extraímos a probabilidade de medir o bitstring de todos os zeros em ambas as execuções. Uma probabilidade de sobrevivência mais alta indica melhor fidelidade, significando que a transpilação introduziu menos ruído. O gráfico abaixo mostra o complemento, 1 - P(|0...0>), de modo que uma barra mais baixa indica melhor fidelidade e pequenas diferenças no erro são mais fáceis de visualizar.
# 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()
Neste caso, o transpilador padrão produziu um circuito mais raso e menor para esta instância específica de 10 qubits, portanto sua maior fidelidade é esperada. Os resultados por circuito variam: como a tabela de resumo acima mostra, a vantagem do transpilador com IA está na menor profundidade de dois qubits em média, não em todos os circuitos individuais. Qual estratégia produz maior fidelidade depende da magnitude da diferença em cada métrica, das características de ruído do hardware e da estrutura do circuito. Sob um modelo de ruído depolarizante uniforme, a contagem total de portas geralmente tem um impacto mais direto no erro acumulado do que a profundidade isoladamente.
Exemplo em hardware de grande escala
Passos 1-4
Aqui todos esses detalhes são reunidos em um fluxo de trabalho claro em maior escala, que é então executado em hardware quântico real.
O código abaixo gera 25 circuitos aleatórios com profundidade 8, onde o número de qubits varia de 26 a 50. Esses circuitos são então transpilados com ambas as estratégias e as mesmas métricas são coletadas. Em seguida, construímos mirror circuits a partir do caso de 26 qubits e os submetemos ao 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álise dos resultados
Os resultados em grande escala reforçam as tendências observadas no exemplo de pequena escala, agora em uma escala mais exigente.
Profundidade de dois qubits: O transpilador com IA continua a oferecer uma profundidade de dois qubits visivelmente menor em toda a faixa de tamanhos de circuito. A otimização de profundidade é um dos principais objetivos para os quais o modelo de roteamento com IA é treinado, e a vantagem é mais pronunciada em contagens de qubits maiores, onde o problema de roteamento se torna mais difícil para métodos heurísticos.
Contagem de portas: O transpilador padrão (SABRE) consistentemente produz circuitos com menos portas em todos os tamanhos de circuito nessa faixa. A heurística do SABRE é especificamente projetada para minimizar a contagem de portas, e nessa escala a vantagem é clara e uniforme.
Tempo de transpilação: A diferença no tempo de transpilação se alarga em escalas maiores. O SABRE permanece quase constante, enquanto o tempo de execução do transpilador com IA cresce mais acentuadamente. Apesar disso, o tempo de execução do transpilador com IA permanece prático para a maioria dos fluxos de trabalho.
Fidelidade do mirror circuit: Ambos os métodos produzem probabilidades de sobrevivência bem abaixo de 1% nessa escala, deixando pouco sinal utilizável. Com contagens totais de portas em torno de 10.000 e profundidades de dois qubits superiores a 1.000, o ruído depolarizante acumulado ao longo do mirror circuit supera a maior parte do sinal. Isso destaca uma limitação fundamental da abordagem de mirror circuit: embora seja simples e não exija simulação clássica, ela não escala bem para circuitos grandes ou profundos, onde ambos os métodos são empurrados para perto do limite de ruído e o pequeno sinal sobrevivente é dominado pelo erro acumulado.
Embora esses resultados ressaltem a eficácia do transpilador com IA, é importante notar suas limitações. O método de síntese com IA está atualmente disponível apenas para certos mapas de acoplamento, o que pode restringir sua aplicabilidade mais ampla. Essa restrição deve ser considerada ao avaliar seu uso em diferentes cenários.
Próximos passos
Se você achou este trabalho interessante, pode se interessar pelo seguinte material: