{ "cells": [ { "cell_type": "markdown", "id": "1ed79d34-1831-47cb-9985-5bb7dacc70e0", "metadata": {}, "source": [ "---\n", "title: \"Otimização da transpilação com o SABRE\"\n", "description: \"Otimize circuitos quânticos utilizando o layout e o roteamento do SABRE para execução em hardware em grande escala.\"\n", "---\n", "\n", "{/* cspell:ignore ylabel xlabel fontsize sharex edgecolor, fontweight, elinewidth, ecolor, prerouter, ylim */}\n", "\n", "\n", "\n", "# Otimização da transpilação com o SABRE\n", "\n", "*Estimativa de tempo de execução: 1 minuto em um processador Heron r2 (NOTA: Trata-se apenas de uma estimativa. (O tempo de execução pode variar.)*\n", "\n" ] }, { "cell_type": "markdown", "id": "d6834016-1525-42d7-aa21-0fef9d957ecd", "metadata": {}, "source": [ "\n", "\n", "## Resultados do aprendizado\n", "\n", "Depois de concluir este tutorial, você deverá compreender:\n", "\n", "* Como configurar os parâmetros do SABRE (`layout_trials`, `swap_trials`, `max_iterations`) para melhorar a qualidade da transpilagem\n", "* O equilíbrio entre o tempo de execução da transpilagem e a qualidade do circuito (profundidade e número de portas)\n", "* Como personalizar a heurística de roteamento do SABRE (`basic`, `decay`, `lookahead`) e comparar seu desempenho em hardware\n", "\n", "\n", "\n", "## Pré-requisitos\n", "\n", "Sugerimos que você esteja familiarizado com os seguintes tópicos antes de seguir com este tutorial:\n", "\n", "* [Circuitos de transpilação](/docs/guides/transpile) : visão geral da transpilação no Qiskit\n", "* [Etapas do transpiler](/docs/guides/transpiler-stages) : etapas de layout e roteamento\n", "* [Configurar gerenciadores de passagens predefinidos](/docs/guides/transpile-with-pass-managers) : personalização dos níveis de otimização\n", "\n", "\n", "\n", "## Segundo plano\n", "\n", "A transpilação converte circuitos quânticos em formatos compatíveis com um hardware quântico específico. Duas etapas fundamentais são a escolha do **layout dos qubits** (mapeamento dos qubits lógicos para os qubits físicos) e **o roteamento das portas** (inserção de portas SWAP para que as portas de múltiplos qubits respeitem a conectividade do dispositivo).\n", "\n", "**O SABRE** ( *algoritmo de busca heurística bidirecional baseado em SWAP* ) otimiza tanto o layout quanto o roteamento. É especialmente eficaz para circuitos de grande escala (mais de 100 qubits) em dispositivos com mapas de acoplamento complexos, como os processadores Heron d IBM®. O SABRE minimiza as portas SWAP e reduz a profundidade do circuito, melhorando a fidelidade de execução. As melhorias recentes no algoritmo “ [LightSABRE](https://arxiv.org/abs/2409.08368) ” reduzem ainda mais os tempos de execução e o número de portas lógicas.\n", "\n", "Neste tutorial, você irá, em primeiro lugar, configurar `SabreLayout` o programa com diferentes parâmetros para otimizar um pequeno circuito GHZ e observar o impacto na fidelidade da execução. Em seguida, você comparará as heurísticas de roteamento do SABRE em grande escala em hardware real.\n", "\n" ] }, { "cell_type": "markdown", "id": "50cf9d9f-c875-49d5-83b0-c691363615ab", "metadata": {}, "source": [ "\n", "\n", "## Requisitos\n", "\n", "Antes de iniciar este tutorial, verifique se você tem os seguintes itens instalados:\n", "\n", "* Qiskit SDK v2.0 ou versão posterior, com suporte [à visualização](/docs/api/qiskit/visualization)\n", "* Qiskit Runtime v0.22 ou posterior (`pip install qiskit-ibm-runtime`)\n", "* Qiskit Aer (`pip install qiskit-aer`)\n", "\n" ] }, { "cell_type": "markdown", "id": "6d9ad2c3-1b10-4a22-8b75-608869be0ac7", "metadata": {}, "source": [ "\n", "\n", "## Instalação\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "6d93c123-b92e-434d-8361-8115509e6d5f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Using backend: ibm_kingston\n" ] } ], "source": [ "from qiskit import QuantumCircuit\n", "from qiskit.quantum_info import SparsePauliOp\n", "from qiskit_ibm_runtime import QiskitRuntimeService\n", "from qiskit_ibm_runtime import EstimatorOptions\n", "from qiskit_ibm_runtime import EstimatorV2 as Estimator\n", "from qiskit_aer.primitives import EstimatorV2 as AerEstimator\n", "from qiskit.transpiler.passes import (\n", " SabreLayout,\n", " SabreSwap,\n", " BarrierBeforeFinalMeasurements,\n", " StarPreRouting,\n", ")\n", "from qiskit.transpiler.passes.layout.vf2_layout import VF2LayoutStopReason\n", "from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n", "from qiskit.passmanager.flow_controllers import ConditionalController\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import time\n", "\n", "seed = 42\n", "\n", "service = QiskitRuntimeService(\n", " channel=\"ibm_cloud\",\n", " token=\"\", # Replace with your actual API token\n", " instance=\"\", # Replace with your instance name if needed\n", ")\n", "backend = service.least_busy(operational=True, simulator=False)\n", "\n", "\n", "print(f\"Using backend: {backend.name}\")" ] }, { "cell_type": "markdown", "id": "c34842c6-5e1b-4658-8e91-15149280c783", "metadata": {}, "source": [ "\n", "\n", "## Exemplo de simulador em pequena escala\n", "\n", "Nesta seção, utiliza-se um **simulador com ruído** baseado no modelo de ruído do backend real para demonstrar como diferentes `SabreLayout` configurações afetam tanto a qualidade da transpilagem quanto a fidelidade da execução. O uso de `qiskit_aer` com um modelo de ruído derivado de dados reais de calibração de hardware permite que você teste a transpilação sem consumir créditos de hardware.\n", "\n" ] }, { "cell_type": "markdown", "id": "a2bcc2b2-727b-447f-b680-a23e3b9e0c3c", "metadata": {}, "source": [ "\n", "\n", "### Passo 1: Mapear entradas clássicas para um problema quântico\n", "\n", "Construímos um **circuito GHZ com topologia em estrela** com 15 qubits. O primeiro qubit é o nó central, com portas CNOT conectando-o diretamente a todos os outros qubits. Essa topologia cria um problema complexo de layout, pois não se corresponde de forma simples ao mapa de acoplamento do dispositivo.\n", "\n", "Também definimos `ZZ` operadores para medir as correlações de entrelaçamento $\\langle Z_0 Z_i \\rangle$ entre pares de qubits.\n", "\n", "![ghz\\_star\\_topology.png](https://quantum.cloud.ibm.com/docs/images/tutorials/transpilation-optimizations-with-sabre/ghz_star_topology.avif)\n", "\n", "\n", " O SABRE é um algoritmo de uso geral e não faz suposições sobre a estrutura do circuito. Para esse circuito GHZ com topologia em estrela, já se conhece, de fato, um roteamento ideal: o [`StarPreRouting`](/docs/api/qiskit/qiskit.transpiler.passes.StarPreRouting) pass detecta os subcircuitos em estrela e os reescreve em uma cadeia linear que se mapeia diretamente para qualquer backend com um caminho linear suficientemente longo. Este tutorial se concentra no SABRE porque ele funciona para circuitos arbitrários, mas se você sabe que seu circuito possui uma estrutura especial bem definida, aplicar uma etapa especializada como `StarPreRouting` essa antes do roteamento pode superar qualquer busca heurística.\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "08a8c4df-b1a5-45b7-9808-ca4e5d7631d8", "metadata": {}, "outputs": [], "source": [ "num_qubits_sim = 15\n", "\n", "# Create star-topology GHZ circuit\n", "qc_sim = QuantumCircuit(num_qubits_sim)\n", "qc_sim.h(0)\n", "for i in range(1, num_qubits_sim):\n", " qc_sim.cx(0, i)\n", "qc_sim.measure_all()\n", "\n", "# ZZ operators: Z on qubit 0 and qubit i, identity elsewhere\n", "operator_strings_sim = [\n", " \"Z\" + \"I\" * i + \"Z\" + \"I\" * (num_qubits_sim - 2 - i)\n", " for i in range(num_qubits_sim - 1)\n", "]\n", "operators_sim = [SparsePauliOp(op) for op in operator_strings_sim]" ] }, { "cell_type": "markdown", "id": "25ac8d92-6362-4d4e-a133-2914703df658", "metadata": {}, "source": [ "\n", "\n", "### Etapa 2: Otimizar o problema para execução em hardware quântico\n", "\n", "`SabreLayout`O gerenciador de passagens predefinido `optimization_level=3` já utiliza isso, mas com valores padrão conservadores. Para analisar o impacto de configurações mais rigorosas, essa etapa é substituída por uma configurada sob `SabreLayout` medida para uma busca mais agressiva, enquanto todas as outras etapas da fase de layout permanecem inalteradas. Como ponto de comparação adicional, um quarto gerenciador de passagens mantém a configuração padrão `SabreLayout` , mas adiciona [`StarPreRouting`](/docs/api/qiskit/qiskit.transpiler.passes.StarPreRouting) à fase de inicialização. `StarPreRouting` é uma etapa *que leva em conta a estrutura,* que detecta subcircuitos em forma de estrela e os reescreve em uma cadeia linear antes do roteamento.\n", "\n", "O fluxo de trabalho é o seguinte:\n", "\n", "1. **Inspecione** o gerenciador de passagens padrão para verificar onde `SabreLayout` ele se encontra dentro do `layout` palco.\n", "2. **Substitua** essa passagem por uma instância personalizada `SabreLayout` usando `PassManager.replace(index, passes=...)`, e crie a `pm_star` variante com `pm.init += StarPreRouting()`.\n", "3. **Execute** todos os quatro gerenciadores de passagem e compare as métricas.\n", "\n", "As quatro configurações são:\n", "\n", "| Configuração | Descrição |\n", "| --------------- | ------------------------------------------------------------------------------------------------------------ |\n", "| `pm_1` (padrão) | Predefinição padrão “ level-3 ” (`SabreLayout` com `max_iterations=4`, `layout_trials=20`, `swap_trials=20`) |\n", "| `pm_2` | Personalizado `SabreLayout` (`max_iterations=4`, `layout_trials=200`, `swap_trials=200`) |\n", "| `pm_3` | Personalizado `SabreLayout` (`max_iterations=8`, `layout_trials=200`, `swap_trials=200`) |\n", "| `pm_star` | Configuração padrão com `StarPreRouting` adicionada à fase de inicialização |\n", "\n", "**Parâmetros principais do SABRE:**\n", "\n", "* **`layout_trials` / `swap_trials`**: Controla quantos layouts e soluções de roteamento possíveis o SABRE analisa. Aumentar o número de tentativas significa que o SABRE analisa um espaço de busca mais amplo, aumentando a chance de encontrar uma solução melhor.\n", "* **`max_iterations`**: Determina quantos ciclos de refinamento de roteamento para frente e para trás o SABRE realiza em cada candidato. O SABRE aprimora o layout de forma iterativa, aprendendo com o feedback do roteamento; portanto, quanto mais iterações, melhores são as melhorias.\n", "\n", "Ambas as opções implicam um tempo de transpilação mais longo, mas os circuitos resultantes são mais curtos e utilizam menos portas, o que reduz diretamente a decoerência e os erros de porta em hardware real.\n", "\n", "**Etapa 2a: Verifique o gerenciador de senhas padrão.** A `StagedPassManager` é composta por estágios (`init`, `layout`, `routing`, `translation`, `optimization`, `scheduling`), sendo cada um deles um `PassManager`. A chamada `.draw()` de uma função no palco representa suas passagens como um gráfico, para que possamos ver onde `SabreLayout` ela está localizada.\n", "\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "b40fe1e0-41cd-4e8b-acb9-801872d35f1f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Build the default pass manager (no modifications yet)\n", "pm_1 = generate_preset_pass_manager(\n", " optimization_level=3, backend=backend, seed_transpiler=seed\n", ")\n", "\n", "# Visualize the layout stage to see where SabreLayout sits\n", "pm_1.layout.draw()" ] }, { "cell_type": "markdown", "id": "8f9e5393-af3b-4d3d-a0d8-d20585b02895", "metadata": {}, "source": [ "No diagrama acima, a `SabreLayout` passagem que queremos personalizar está localizada `ConditionalController` na posição **\\[2]** do estágio de layout. Esse controlador faz duas coisas:\n", "\n", "* Ele funciona como um gate `SabreLayout` , de modo que só é executado quando `VF2Layout` o \\[1] não consegue encontrar um mapeamento perfeito (caso contrário, o layout perfeito VF2 é mantido).\n", "* Isso é precedido `SabreLayout` por uma `BarrierBeforeFinalMeasurements` etapa que evita que as medições sejam reordenadas durante o roteamento interno d SabreLayout's.\n", "\n", "Se simplesmente `replace(index=2, passes=sl_2)`, ambos os comportamentos são descartados. Para preservá-los, voltamos a embrulhar nosso produto personalizado `SabreLayout` no mesmo `ConditionalController` material (nas mesmas condições e com a barreira protetora) antes de colocá-lo no lugar.\n", "\n", "**Etapa 2b: : Crie passes personalizados `SabreLayout` e substitua os padrão.**\n", "\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "79075a21-8f36-4fd9-9d0d-bd0e97395b60", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cmap = backend.coupling_map\n", "\n", "# Custom SabreLayout passes with more aggressive search\n", "sl_2 = SabreLayout(\n", " coupling_map=cmap,\n", " seed=seed,\n", " max_iterations=4,\n", " layout_trials=200,\n", " swap_trials=200,\n", ")\n", "sl_3 = SabreLayout(\n", " coupling_map=cmap,\n", " seed=seed,\n", " max_iterations=8,\n", " layout_trials=200,\n", " swap_trials=200,\n", ")\n", "\n", "\n", "# Same condition the preset uses: only run SabreLayout when VF2Layout did not\n", "# find a perfect mapping. This preserves any perfect layout VF2 produced at [1].\n", "def _vf2_match_not_found(property_set):\n", " if property_set[\"layout\"] is None:\n", " return True\n", " return (\n", " property_set[\"VF2Layout_stop_reason\"] is not None\n", " and property_set[\"VF2Layout_stop_reason\"]\n", " is not VF2LayoutStopReason.SOLUTION_FOUND\n", " )\n", "\n", "\n", "def wrap_sabre(sabre_pass):\n", " \"\"\"Re-wrap a SabreLayout in the original ConditionalController + barrier.\"\"\"\n", " return ConditionalController(\n", " [\n", " BarrierBeforeFinalMeasurements(\n", " \"qiskit.transpiler.internal.routing.protection.barrier\"\n", " ),\n", " sabre_pass,\n", " ],\n", " condition=_vf2_match_not_found,\n", " )\n", "\n", "\n", "# Build two fresh pass managers and swap in the wrapped custom SabreLayout at index 2\n", "pm_2 = generate_preset_pass_manager(\n", " optimization_level=3, backend=backend, seed_transpiler=seed\n", ")\n", "pm_3 = generate_preset_pass_manager(\n", " optimization_level=3, backend=backend, seed_transpiler=seed\n", ")\n", "pm_2.layout.replace(index=2, passes=wrap_sabre(sl_2))\n", "pm_3.layout.replace(index=2, passes=wrap_sabre(sl_3))\n", "\n", "# Build pm_star: default preset with StarPreRouting added to the init stage\n", "pm_star = generate_preset_pass_manager(\n", " optimization_level=3, backend=backend, seed_transpiler=seed\n", ")\n", "pm_star.init += StarPreRouting()\n", "\n", "# Visualize pm_3 after replacement (pm_2 has the same structure, only max_iterations differs)\n", "pm_3.layout.draw()" ] }, { "cell_type": "markdown", "id": "378a5829-b18b-4359-827f-b052c7cc1b89", "metadata": {}, "source": [ "A posição **\\[2]** agora é um `ConditionalController` novamente — de formato idêntico ao padrão, mas o interno `SabreLayout` é o nosso personalizado (com `layout_trials=200`, `swap_trials=200`, e `max_iterations=8` para `pm_3`; `pm_2` é idêntico, exceto por `max_iterations=4`). A barreira protetora e o `_vf2_match_not_found` sistema de portas são mantidos; portanto, a única diferença entre `pm_2`/`pm_3` e `pm_1` é a própria configuração do SABRE. `pm_star` mantém a configuração padrão `SabreLayout` e apenas adiciona `StarPreRouting` no final da fase de inicialização.\n", "\n", "**Etapa 2c: Execute cada gerenciador de passagem e compare os resultados.**\n", "\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "fd52f8dd-862b-46e2-b93d-0b35f47a3d83", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "pm_1 (4,20,20): 2Q Depth 38, Size 183, Time 0.01s\n", "pm_2 (4,200,200): 2Q Depth 36, Size 183, Time 0.15s\n", "pm_3 (8,200,200): 2Q Depth 30, Size 158, Time 0.16s\n", "pm_star (default + StarPreRouting): 2Q Depth 26, Size 160, Time 0.01s\n", "\n", "Improvement vs. default (pm_1):\n", " pm_2 (4,200,200): 2Q depth +5.3%, size +0.0%\n", " pm_3 (8,200,200): 2Q depth +21.1%, size +13.7%\n", " pm_star (default + StarPreRouting): 2Q depth +31.6%, size +12.6%\n" ] } ], "source": [ "results_sim = {}\n", "for name, pm in [\n", " (\"pm_1 (4,20,20)\", pm_1),\n", " (\"pm_2 (4,200,200)\", pm_2),\n", " (\"pm_3 (8,200,200)\", pm_3),\n", " (\"pm_star (default + StarPreRouting)\", pm_star),\n", "]:\n", " t0 = time.time()\n", " tqc = pm.run(qc_sim)\n", " elapsed = time.time() - t0\n", " depth = tqc.depth(lambda x: x.operation.num_qubits == 2)\n", " size = tqc.size()\n", " ops_mapped = [op.apply_layout(tqc.layout) for op in operators_sim]\n", " results_sim[name] = {\n", " \"tqc\": tqc,\n", " \"ops\": ops_mapped,\n", " \"depth\": depth,\n", " \"size\": size,\n", " \"time\": elapsed,\n", " }\n", " print(f\"{name}: 2Q Depth {depth}, Size {size}, Time {elapsed:.2f}s\")\n", "\n", "# Print improvement relative to default (pm_1)\n", "baseline = results_sim[\"pm_1 (4,20,20)\"]\n", "print(\"\\nImprovement vs. default (pm_1):\")\n", "for name in [\n", " \"pm_2 (4,200,200)\",\n", " \"pm_3 (8,200,200)\",\n", " \"pm_star (default + StarPreRouting)\",\n", "]:\n", " r = results_sim[name]\n", " depth_pct = (baseline[\"depth\"] - r[\"depth\"]) / baseline[\"depth\"] * 100\n", " size_pct = (baseline[\"size\"] - r[\"size\"]) / baseline[\"size\"] * 100\n", " print(f\" {name}: 2Q depth {depth_pct:+.1f}%, size {size_pct:+.1f}%\")" ] }, { "cell_type": "markdown", "id": "0c27cbdb-c065-4a36-a0ef-6c9572c7a4a5", "metadata": {}, "source": [ "Todos os três gerenciadores de passagem modificados produziram circuitos com profundidade de 2Q menor do que a padrão. As configurações agressivas do SABRE (`pm_2` e `pm_3`) sacrificam um tempo de transpilação mais longo em troca de uma busca mais ampla, enquanto `pm_star` aproveita a estrutura em estrela do circuito e produz um resultado ainda mais superficial sem incorrer em nenhum custo extra de transpilação. Os ganhos exatos variam de execução para execução, mas a tendência geral é consistente: mais ensaios e iterações do SABRE permitem que a busca heurística explore um espaço mais amplo, e passagens que levam em conta a estrutura, como `StarPreRouting` , podem contornar totalmente essa busca quando a forma do circuito coincide.\n", "\n", "Mesmo nessa escala reduzida (15 qubits), a margem para melhorias é suficiente para que todas as três abordagens superem o resultado padrão. Com circuitos maiores (mais de 100 qubits), o espaço de busca cresce drasticamente e os benefícios tanto do aumento do número de tentativas quanto das passagens que levam em conta a estrutura tornam-se muito mais evidentes, como será mostrado na seção sobre grande escala.\n", "\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "bf75c45a-2c3e-4ef6-8336-0b3f69e6e8fb", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "pm_names = list(results_sim.keys())\n", "depths = [results_sim[n][\"depth\"] for n in pm_names]\n", "sizes = [results_sim[n][\"size\"] for n in pm_names]\n", "times = [results_sim[n][\"time\"] for n in pm_names]\n", "colors = [\"#404080\", \"#2a9d8f\", \"#a8d05e\", \"#e29bdd\"]\n", "x = np.arange(len(pm_names))\n", "\n", "fig, axs = plt.subplots(1, 3, figsize=(14, 5))\n", "\n", "# 2Q Depth\n", "bars = axs[0].bar(x, depths, color=colors)\n", "axs[0].set_ylabel(\"2Q Depth\", fontsize=11)\n", "axs[0].set_title(\"Two-Qubit Gate Depth\", fontsize=13)\n", "axs[0].set_ylim(0, max(depths) * 1.2)\n", "for bar, val in zip(bars, depths):\n", " axs[0].text(\n", " bar.get_x() + bar.get_width() / 2,\n", " bar.get_height() + max(depths) * 0.02,\n", " str(val),\n", " ha=\"center\",\n", " va=\"bottom\",\n", " fontsize=11,\n", " fontweight=\"bold\",\n", " )\n", "for i in range(1, len(depths)):\n", " pct = (depths[0] - depths[i]) / depths[0] * 100\n", " if pct != 0:\n", " axs[0].text(\n", " bars[i].get_x() + bars[i].get_width() / 2,\n", " bars[i].get_height() / 2,\n", " f\"{pct:+.0f}%\",\n", " ha=\"center\",\n", " va=\"center\",\n", " fontsize=10,\n", " color=\"white\",\n", " fontweight=\"bold\",\n", " )\n", "\n", "# Size\n", "bars = axs[1].bar(x, sizes, color=colors)\n", "axs[1].set_ylabel(\"Gate Count\", fontsize=11)\n", "axs[1].set_title(\"Circuit Size\", fontsize=13)\n", "axs[1].set_ylim(0, max(sizes) * 1.2)\n", "for bar, val in zip(bars, sizes):\n", " axs[1].text(\n", " bar.get_x() + bar.get_width() / 2,\n", " bar.get_height() + max(sizes) * 0.02,\n", " str(val),\n", " ha=\"center\",\n", " va=\"bottom\",\n", " fontsize=11,\n", " fontweight=\"bold\",\n", " )\n", "for i in range(1, len(sizes)):\n", " pct = (sizes[0] - sizes[i]) / sizes[0] * 100\n", " if abs(pct) > 0.1:\n", " axs[1].text(\n", " bars[i].get_x() + bars[i].get_width() / 2,\n", " bars[i].get_height() / 2,\n", " f\"{pct:+.0f}%\",\n", " ha=\"center\",\n", " va=\"center\",\n", " fontsize=10,\n", " color=\"white\",\n", " fontweight=\"bold\",\n", " )\n", "\n", "# Time\n", "bars = axs[2].bar(x, times, color=colors)\n", "axs[2].set_ylabel(\"Time (s)\", fontsize=11)\n", "axs[2].set_title(\"Transpilation Time\", fontsize=13)\n", "axs[2].set_ylim(0, max(times) * 1.3)\n", "for bar, val in zip(bars, times):\n", " axs[2].text(\n", " bar.get_x() + bar.get_width() / 2,\n", " bar.get_height() + max(times) * 0.03,\n", " f\"{val:.2f}s\",\n", " ha=\"center\",\n", " va=\"bottom\",\n", " fontsize=11,\n", " fontweight=\"bold\",\n", " )\n", "\n", "for ax in axs:\n", " ax.set_xticks(x)\n", " ax.set_xticklabels(pm_names, fontsize=8, rotation=15)\n", " ax.grid(axis=\"y\", linestyle=\"--\", alpha=0.5)\n", "\n", "plt.suptitle(\n", " \"Transpilation quality vs. configuration\",\n", " fontsize=14,\n", " fontweight=\"bold\",\n", " y=1.02,\n", ")\n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "6a233965-1358-420b-8823-5f4e206090b4", "metadata": {}, "source": [ "\n", "\n", "### Passo 3: Execute usando Qiskit primitives\n", "\n", "Executamos cada circuito transpilado **10 vezes** usando o Aer `EstimatorV2` com um modelo de ruído derivado do backend real. Como os resultados das simulações, que apresentam ruído, variam entre as execuções, calcular a média de várias execuções proporciona estimativas de fidelidade mais confiáveis e nos permite quantificar a incerteza estatística por meio de barras de erro.\n", "\n" ] }, { "cell_type": "code", "execution_count": 15, "id": "a91b9887-c8cf-48fd-a6fb-a5506d201f8d", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Run 1/10 done\n", "Run 2/10 done\n", "Run 3/10 done\n", "Run 4/10 done\n", "Run 5/10 done\n", "Run 6/10 done\n", "Run 7/10 done\n", "Run 8/10 done\n", "Run 9/10 done\n", "Run 10/10 done\n", "pm_1 (4,20,20): mean fidelity = 0.9510 +/- 0.0094\n", "pm_2 (4,200,200): mean fidelity = 0.9513 +/- 0.0043\n", "pm_3 (8,200,200): mean fidelity = 0.9540 +/- 0.0065\n", "pm_star (default + StarPreRouting): mean fidelity = 0.9547 +/- 0.0072\n" ] } ], "source": [ "# Create a noisy estimator from the real backend's noise model\n", "noisy_estimator = AerEstimator.from_backend(backend)\n", "\n", "num_runs = 10\n", "# sim_all_runs[name] = list of arrays, one per run\n", "sim_all_runs = {name: [] for name in results_sim}\n", "\n", "for run in range(num_runs):\n", " for name, r in results_sim.items():\n", " job = noisy_estimator.run([(r[\"tqc\"], r[\"ops\"])])\n", " evs = list(job.result()[0].data.evs)\n", " sim_all_runs[name].append(evs)\n", " print(f\"Run {run + 1}/{num_runs} done\")\n", "\n", "# Compute mean and std across runs for each config\n", "sim_stats = {}\n", "for name in results_sim:\n", " all_evs = np.array(sim_all_runs[name]) # shape (num_runs, num_operators)\n", " sim_stats[name] = {\n", " \"mean\": np.mean(all_evs, axis=0),\n", " \"std\": np.std(all_evs, axis=0),\n", " \"overall_mean\": np.mean(all_evs),\n", " \"overall_std\": np.std(\n", " np.mean(all_evs, axis=1)\n", " ), # std of per-run averages\n", " }\n", " print(\n", " f\"{name}: mean fidelity = {sim_stats[name]['overall_mean']:.4f} +/- {sim_stats[name]['overall_std']:.4f}\"\n", " )" ] }, { "cell_type": "markdown", "id": "89e6c70f-4da4-470f-b0fa-2e2521c82f6f", "metadata": {}, "source": [ "Como se trata de um circuito pequeno, os valores de fidelidade ficam relativamente próximos nas quatro configurações. Os circuitos são curtos o suficiente para que o ruído do hardware não prejudique significativamente nem mesmo a versão menos otimizada. A fidelidade média acompanha, de maneira geral, a profundidade d 2Q : `pm_3` e `pm_star`, os dois circuitos mais rasos, alcançam as maiores fidelidades e estão praticamente empatados dentro de suas barras de erro. `pm_2` é um contra-exemplo útil: embora sua profundidade de 2Q seja menor do que `pm_1`a de 's, sua fidelidade média acaba sendo ligeiramente menor também, o que nos lembra que a relação entre profundidade e fidelidade é estatística, e não determinística. Os qubits específicos selecionados por um layout e a calibração desses qubits durante a execução também são importantes.\n", "\n" ] }, { "cell_type": "markdown", "id": "e601648b-8f5f-4111-ba35-f64af63da909", "metadata": {}, "source": [ "\n", "\n", "### Etapa 4: Pós-processamento e retorno do resultado no formato clássico desejado\n", "\n", "Em seguida, represente graficamente as correlações de entrelaçamento $\\langle Z_0 Z_i \\rangle$ em função da distância entre os qubits, juntamente com a **correlação média** como uma única métrica de fidelidade. Em um caso ideal (sem ruído), todas as correlações seriam 1. Devido ao ruído realista, cada porta adicional introduz erros e cada passo de tempo adicional permite a decoerência; portanto, um circuito transpilado com menor profundidade e menos portas (especialmente portas de dois qubits) deve preservar melhor o entrelaçamento.\n", "\n" ] }, { "cell_type": "code", "execution_count": 16, "id": "a6dac5ed-a963-458a-ada1-89c915f036e0", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "data_sim = list(range(1, len(operators_sim) + 1))\n", "markers = [\"o\", \"s\", \"^\", \"*\"]\n", "colors_line = [\"#404080\", \"#2a9d8f\", \"#a8d05e\", \"#e29bdd\"]\n", "\n", "fig, (ax1, ax2) = plt.subplots(\n", " 1, 2, figsize=(14, 5), gridspec_kw={\"width_ratios\": [2.5, 1]}\n", ")\n", "\n", "# Left: correlations vs distance with error bars (mean +/- 1 std)\n", "for (name, stats), marker, color in zip(\n", " sim_stats.items(), markers, colors_line\n", "):\n", " ax1.errorbar(\n", " data_sim,\n", " stats[\"mean\"],\n", " yerr=stats[\"std\"],\n", " marker=marker,\n", " label=name,\n", " color=color,\n", " linewidth=2,\n", " capsize=3,\n", " capthick=1,\n", " elinewidth=1,\n", " )\n", "\n", "ax1.set_xlabel(\"Distance between qubits $i$\", fontsize=11)\n", "ax1.set_ylabel(r\"$\\langle Z_0 Z_i \\rangle$\", fontsize=11)\n", "ax1.set_title(\n", " \"Entanglement correlations vs. qubit distance (avg. of 10 runs)\",\n", " fontsize=12,\n", ")\n", "ax1.legend(fontsize=9)\n", "ax1.grid(alpha=0.3)\n", "\n", "# Right: mean correlation bar chart with error bars\n", "names = list(sim_stats.keys())\n", "means = [sim_stats[n][\"overall_mean\"] for n in names]\n", "stds = [sim_stats[n][\"overall_std\"] for n in names]\n", "x_bar = np.arange(len(names))\n", "bars = ax2.bar(\n", " x_bar, means, yerr=stds, color=colors_line, capsize=5, ecolor=\"gray\"\n", ")\n", "ax2.set_ylabel(r\"Mean $\\langle Z_0 Z_i \\rangle$\", fontsize=11)\n", "ax2.set_title(\"Average fidelity\", fontsize=13, pad=12)\n", "y_range = max(means) - min(means) if max(means) != min(means) else 0.01\n", "# Top of ylim accounts for the bar height + std error bar + headroom for the value label\n", "y_top = max(m + s for m, s in zip(means, stds)) + y_range * 1.5\n", "ax2.set_ylim(min(means) - y_range * 0.8, y_top)\n", "for bar, val, std in zip(bars, means, stds):\n", " ax2.text(\n", " bar.get_x() + bar.get_width() / 2,\n", " bar.get_height() + std + y_range * 0.15,\n", " f\"{val:.4f}\",\n", " ha=\"center\",\n", " va=\"bottom\",\n", " fontsize=10,\n", " fontweight=\"bold\",\n", " )\n", "# Annotate % change vs pm_1\n", "baseline_mean = means[0]\n", "for i in range(1, len(means)):\n", " pct = (means[i] - baseline_mean) / baseline_mean * 100\n", " if abs(pct) > 0.01:\n", " mid_y = (means[i] + ax2.get_ylim()[0]) / 2\n", " ax2.text(\n", " bars[i].get_x() + bars[i].get_width() / 2,\n", " mid_y,\n", " f\"{pct:+.1f}%\",\n", " ha=\"center\",\n", " va=\"center\",\n", " fontsize=10,\n", " color=\"white\",\n", " fontweight=\"bold\",\n", " )\n", "ax2.set_xticks(x_bar)\n", "ax2.set_xticklabels(names, fontsize=8, rotation=15)\n", "ax2.grid(axis=\"y\", linestyle=\"--\", alpha=0.5)\n", "\n", "fig.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "05235ab1-b473-4267-a34c-5f56e728550b", "metadata": {}, "source": [ "Os resultados mostram uma clara relação entre a qualidade da transpilagem e a fidelidade da execução, com algumas ressalvas importantes:\n", "\n", "* **`pm_1` (padrão)** : Linha de base. Com apenas 20 tentativas e quatro iterações, o SABRE tem margem limitada para otimização, o que resulta no circuito mais profundo entre aqueles gerados exclusivamente pelo SABRE.\n", "* **`pm_2` (mais testes)** : Ao explorar dez vezes mais candidatos, obtém-se um layout ligeiramente menos profundo, mas a fidelidade média permanece praticamente estável (e pode até cair abaixo da linha de base devido ao ruído), pois o ganho de profundidade é pequeno nessa escala.\n", "* **`pm_3` (mais testes + mais iterações)** : Ao dobrar `max_iterations` o número para 8, o SABRE passa a ter mais ciclos de refinamento, produzindo o circuito mais superficial criado exclusivamente pelo SABRE e a maior fidelidade média na comparação.\n", "* **`pm_star` (padrão + StarPreRouting )** : Adiciona `StarPreRouting` à fase de inicialização de uma predefinição que, de outra forma, seria padrão. A reescrita com reconhecimento de estrutura reduz o símbolo “\\*” a uma cadeia linear que o restante do transpiler mapeia para o caminho linear do dispositivo, produzindo o circuito mais raso no geral (ligeiramente melhor do que `pm_3`) e igualando `pm_3` em termos de fidelidade dentro das barras de erro. Isso é feito com o mesmo tempo de transpilagem que o padrão, já que a reescrita é essencialmente gratuita em comparação com a busca estocástica do SABRE.\n", "\n", "Observe que aumentar `max_iterations` nem sempre traz um impacto positivo. Nesse caso, isso ajudou significativamente, mas, para outros circuitos ou backends, as iterações adicionais podem não trazer melhorias adicionais ou podem até prejudicar ligeiramente o desempenho devido à otimização excessiva de um mínimo local. Em geral, você deve aumentar `layout_trials` e `swap_trials` tanto quanto seu tempo disponível permitir, já que um maior número de tentativas sempre aumenta a chance de encontrar um layout melhor. Vale a pena testar o aumento `max_iterations` , mas ele deve ser validado para o seu caso de uso específico. Passos especializados como `StarPreRouting` são semelhantes em princípio, mas dependem mais do circuito: eles só ajudam quando o circuito realmente contém a estrutura à qual se destinam. O ganho é grande quando aplicável e é zero nos demais casos, mas não custa praticamente nada tentar.\n", "\n" ] }, { "cell_type": "markdown", "id": "c2b60e42-4aa2-4dc1-8a11-022072e79776", "metadata": {}, "source": [ "\n", "\n", "## Exemplo de hardware em grande escala\n", "\n", "Além de ajustar o número de tentativas, o SABRE permite personalizar a **heurística de roteamento**. O SABRE oferece três heurísticas:\n", "\n", "* **`basic`**: Uma abordagem gananciosa simples que seleciona a troca que minimiza a distância imediata até o próximo portão.\n", "* **`decay`** (padrão): Atribui pesos dinamicamente aos qubits com base na atividade recente, evitando trocas repetidas nos mesmos qubits.\n", "* **`lookahead`**: Avalia os custos futuros de roteamento, analisando antecipadamente os próximos pontos de passagem, a fim de identificar possíveis sequências de troca mais vantajosas.\n", "\n", "Para usar uma heurística personalizada, crie uma `SabreSwap` passagem e conecte-a a `SabreLayout` por meio do `routing_pass` parâmetro.\n", "\n", "`SabreLayout`Um quarto gerenciador de passagens é adicionado à comparação: `pm_star_hw`, que mantém as configurações padrão,`SabreSwap` mas adiciona `StarPreRouting` à fase de inicialização. Nessa escala (100 qubits), a busca SABRE se torna mais complexa, e a reescrita de uma estrutura em estrela para uma cadeia linear se torna uma vantagem clara, pois um processador Heron possui caminhos lineares suficientemente longos para acomodar o circuito resultante.\n", "\n", "Aqui, comparamos as três heurísticas do SABRE, além de `StarPreRouting` em escala, em um circuito GHZ de 100 qubits. Realizamos vários testes de layout com diferentes sementes para as configurações do SABRE, selecionamos o melhor circuito transpilado de cada um deles e os submetemos, todos, a hardware real juntamente com `StarPreRouting` o resultado.\n", "\n" ] }, { "cell_type": "markdown", "id": "d755fafa-bbbc-4191-9ad9-a77f2af1bedc", "metadata": {}, "source": [ "\n", "\n", "### Etapas 1 a 4 agrupadas em um único bloco de código\n", "\n", "Aqui, todo o fluxo de trabalho é organizado em uma escala maior. Ao usar `SabreSwap` como para `routing_pass` `SabreLayout`, é realizada apenas uma tentativa de layout por chamada; portanto, a célula de código a seguir percorre as sementes em um loop para explorar o espaço de layout.\n", "\n", "Usamos o mesmo `wrap_sabre` auxiliar definido na Etapa 2 em pequena escala (acima) e adicionamos um auxiliar análogo `wrap_routing` , pois o `routing` estágio no índice \\[1] também é um `ConditionalController([BarrierBeforeFinalMeasurements, routing_pass], ...)` — substituí-lo sem mais nada eliminaria, da mesma forma, a barreira protetora e o `_swap_condition` controle de acesso.\n", "\n" ] }, { "cell_type": "code", "execution_count": 9, "id": "4feb0fcf-d305-4741-82a7-b0fe0f0894fc", "metadata": {}, "outputs": [], "source": [ "# -------------------------Step 1-------------------------\n", "\n", "num_qubits = 100\n", "\n", "# Create star-topology GHZ circuit\n", "qc = QuantumCircuit(num_qubits)\n", "qc.h(0)\n", "for i in range(1, num_qubits):\n", " qc.cx(0, i)\n", "qc.measure_all()\n", "\n", "# ZZ operators\n", "operator_strings = [\n", " \"Z\" + \"I\" * i + \"Z\" + \"I\" * (num_qubits - 2 - i)\n", " for i in range(num_qubits - 1)\n", "]\n", "operators = [SparsePauliOp(op) for op in operator_strings]" ] }, { "cell_type": "code", "execution_count": 10, "id": "43ec98c6-f4c6-4584-8ba0-edfb4e99f04a", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "basic:\n", " 2Q depth: min: 524, mean: 570.5, std: 39.9\n", " size : min: 3819, mean: 4227.1, std: 360.6\n", " best seed: 51 (2Q depth=524, size=3852)\n", "decay:\n", " 2Q depth: min: 387, mean: 436.4, std: 41.7\n", " size : min: 2687, mean: 3183.1, std: 459.3\n", " best seed: 45 (2Q depth=387, size=2786)\n", "lookahead:\n", " 2Q depth: min: 364, mean: 424.6, std: 36.5\n", " size : min: 2335, mean: 3014.6, std: 388.1\n", " best seed: 51 (2Q depth=364, size=2485)\n", "StarPreRouting:\n", " 2Q depth: min: 196, mean: 196.0, std: 0.0\n", " size : min: 1151, mean: 1151.0, std: 0.0\n", " best seed: 42 (2Q depth=196, size=1151)\n" ] } ], "source": [ "# -------------------------Step 2-------------------------\n", "\n", "num_seeds = 10\n", "seed_list = [seed + i for i in range(num_seeds)]\n", "swap_trials = 200\n", "\n", "\n", "# The default routing[1] is a ConditionalController([barrier, routing_pass],\n", "# condition=_swap_condition); we re-wrap so the new routing pass keeps the\n", "# protective barrier and is skipped when routing isn't needed (matches the preset).\n", "def _swap_condition(property_set):\n", " return not property_set[\"routing_not_needed\"]\n", "\n", "\n", "def wrap_routing(routing_pass):\n", " return ConditionalController(\n", " [\n", " BarrierBeforeFinalMeasurements(\n", " \"qiskit.transpiler.internal.routing.protection.barrier\"\n", " ),\n", " routing_pass,\n", " ],\n", " condition=_swap_condition,\n", " )\n", "\n", "\n", "heuristic_results = {}\n", "\n", "# Three SABRE heuristics, swept over seeds\n", "for heuristic in [\"basic\", \"decay\", \"lookahead\"]:\n", " trials = []\n", " for s in seed_list:\n", " sr = SabreSwap(\n", " coupling_map=cmap, heuristic=heuristic, trials=swap_trials, seed=s\n", " )\n", " sl = SabreLayout(coupling_map=cmap, routing_pass=sr, seed=s)\n", " pm = generate_preset_pass_manager(\n", " optimization_level=3, backend=backend, seed_transpiler=s\n", " )\n", " # Re-wrap each custom pass in its original ConditionalController + barrier\n", " # (wrap_sabre is defined in the small-scale Step 2 cell above).\n", " pm.layout.replace(index=2, passes=wrap_sabre(sl))\n", " pm.routing.replace(index=1, passes=wrap_routing(sr))\n", "\n", " t0 = time.time()\n", " tqc = pm.run(qc)\n", " elapsed = time.time() - t0\n", " depth = tqc.depth(lambda x: x.operation.num_qubits == 2)\n", " size = tqc.size()\n", " trials.append(\n", " {\n", " \"tqc\": tqc,\n", " \"depth\": depth,\n", " \"size\": size,\n", " \"time\": elapsed,\n", " \"seed\": s,\n", " }\n", " )\n", "\n", " heuristic_results[heuristic] = trials\n", "\n", "# Default preset + StarPreRouting in init, also swept over seeds for a fair comparison\n", "star_trials = []\n", "for s in seed_list:\n", " pm_star_hw = generate_preset_pass_manager(\n", " optimization_level=3, backend=backend, seed_transpiler=s\n", " )\n", " pm_star_hw.init += StarPreRouting()\n", "\n", " t0 = time.time()\n", " tqc = pm_star_hw.run(qc)\n", " elapsed = time.time() - t0\n", " depth = tqc.depth(lambda x: x.operation.num_qubits == 2)\n", " size = tqc.size()\n", " star_trials.append(\n", " {\n", " \"tqc\": tqc,\n", " \"depth\": depth,\n", " \"size\": size,\n", " \"time\": elapsed,\n", " \"seed\": s,\n", " }\n", " )\n", "heuristic_results[\"StarPreRouting\"] = star_trials\n", "\n", "# Print summary for each entry\n", "for label in [\"basic\", \"decay\", \"lookahead\", \"StarPreRouting\"]:\n", " trials = heuristic_results[label]\n", " depths = [t[\"depth\"] for t in trials]\n", " sizes = [t[\"size\"] for t in trials]\n", " best = min(trials, key=lambda t: t[\"depth\"])\n", " print(f\"{label}:\")\n", " print(\n", " f\" 2Q depth: min: {min(depths)}, mean: {np.mean(depths):.1f}, std: {np.std(depths):.1f}\"\n", " )\n", " print(\n", " f\" size : min: {min(sizes)}, mean: {np.mean(sizes):.1f}, std: {np.std(sizes):.1f}\"\n", " )\n", " print(\n", " f\" best seed: {best['seed']} (2Q depth={best['depth']}, size={best['size']})\"\n", " )" ] }, { "cell_type": "code", "execution_count": 11, "id": "eead9bd2-17e0-4f5b-80bc-eb9b30af052e", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "basic: best 2Q depth=524, size=3852 (seed=51)\n", "decay: best 2Q depth=387, size=2786 (seed=45)\n", "lookahead: best 2Q depth=364, size=2485 (seed=51)\n", "StarPreRouting: best 2Q depth=196, size=1151 (seed=42)\n" ] } ], "source": [ "hw_colors = {\n", " \"basic\": \"#ff7f0e\",\n", " \"decay\": \"#d62728\",\n", " \"lookahead\": \"#1f77b4\",\n", " \"StarPreRouting\": \"#2a9d8f\",\n", "}\n", "\n", "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(13, 5))\n", "\n", "for label in [\"basic\", \"decay\", \"lookahead\", \"StarPreRouting\"]:\n", " trials = heuristic_results[label]\n", " depths = [t[\"depth\"] for t in trials]\n", " sizes = [t[\"size\"] for t in trials]\n", " seeds = [t[\"seed\"] for t in trials]\n", " color = hw_colors[label]\n", "\n", " ax1.scatter(\n", " seeds,\n", " depths,\n", " label=label,\n", " color=color,\n", " alpha=0.8,\n", " edgecolor=\"k\",\n", " s=60,\n", " )\n", " ax1.axhline(np.mean(depths), color=color, linestyle=\"--\", alpha=0.5)\n", "\n", " ax2.scatter(\n", " seeds,\n", " sizes,\n", " label=label,\n", " color=color,\n", " alpha=0.8,\n", " edgecolor=\"k\",\n", " s=60,\n", " )\n", " ax2.axhline(np.mean(sizes), color=color, linestyle=\"--\", alpha=0.5)\n", "\n", "ax1.set_xlabel(\"Seed\", fontsize=11)\n", "ax1.set_ylabel(\"2Q Depth\", fontsize=11)\n", "ax1.set_title(\"Two-Qubit Gate Depth per Seed\", fontsize=13)\n", "ax1.legend(fontsize=10)\n", "ax1.grid(alpha=0.3)\n", "\n", "ax2.set_xlabel(\"Seed\", fontsize=11)\n", "ax2.set_ylabel(\"Gate Count\", fontsize=11)\n", "ax2.set_title(\"Circuit Size per Seed\", fontsize=13)\n", "ax2.legend(fontsize=10)\n", "ax2.grid(alpha=0.3)\n", "\n", "plt.suptitle(\n", " \"Transpilation variability across seeds: SABRE heuristics vs. StarPreRouting\",\n", " fontsize=14,\n", " fontweight=\"bold\",\n", " y=1.02,\n", ")\n", "plt.tight_layout()\n", "plt.show()\n", "\n", "# Summary comparison\n", "for label in [\"basic\", \"decay\", \"lookahead\", \"StarPreRouting\"]:\n", " best = min(heuristic_results[label], key=lambda t: t[\"depth\"])\n", " print(\n", " f\"{label}: best 2Q depth={best['depth']}, size={best['size']} (seed={best['seed']})\"\n", " )" ] }, { "cell_type": "code", "execution_count": 12, "id": "5ad47245-41d0-4d90-ba94-dda4cd63705d", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Best basic: 2Q depth=524, size=3852\n", "Best decay: 2Q depth=387, size=2786\n", "Best lookahead: 2Q depth=364, size=2485\n", "Best StarPreRouting: 2Q depth=196, size=1151\n", "basic job: d81q5tnoha1c73bknprg\n", "decay job: d81q5tugbeec73aktopg\n", "lookahead job: d81q5to0bvlc73d1epe0\n", "StarPreRouting job: d81q5u7tjchs73bn82hg\n", "basic job done\n", "decay job done\n", "lookahead job done\n", "StarPreRouting job done\n" ] } ], "source": [ "# -------------------------Step 3: Execute on hardware-------------------------\n", "\n", "best_circuits = {}\n", "for label in [\"basic\", \"decay\", \"lookahead\", \"StarPreRouting\"]:\n", " best_circuits[label] = min(\n", " heuristic_results[label], key=lambda t: t[\"depth\"]\n", " )\n", " b = best_circuits[label]\n", " print(f\"Best {label}: 2Q depth={b['depth']}, size={b['size']}\")\n", "\n", "options = EstimatorOptions()\n", "options.resilience_level = 2\n", "options.dynamical_decoupling.enable = True\n", "options.dynamical_decoupling.sequence_type = \"XY4\"\n", "estimator = Estimator(backend, options=options)\n", "\n", "hw_jobs = {}\n", "hw_ops = {}\n", "for label, best in best_circuits.items():\n", " hw_ops[label] = [op.apply_layout(best[\"tqc\"].layout) for op in operators]\n", " hw_jobs[label] = estimator.run([(best[\"tqc\"], hw_ops[label])])\n", " print(f\"{label} job: {hw_jobs[label].job_id()}\")\n", "estimator.options.environment.job_tags = [\"TUT_TOWS\"]\n", "\n", "hw_results = {}\n", "for label, job in hw_jobs.items():\n", " hw_results[label] = job.result()[0]\n", " print(f\"{label} job done\")" ] }, { "cell_type": "code", "execution_count": 13, "id": "0280b0b9-6320-43e5-8396-f82f9e718319", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "Mean fidelity:\n", " basic: 0.0344\n", " decay: 0.1298\n", " lookahead: 0.1857\n", " StarPreRouting: 0.3295\n" ] } ], "source": [ "# -------------------------Step 4: Post-process-------------------------\n", "\n", "data = list(range(1, len(operators) + 1))\n", "hw_markers = {\n", " \"basic\": \"D\",\n", " \"decay\": \"o\",\n", " \"lookahead\": \"s\",\n", " \"StarPreRouting\": \"*\",\n", "}\n", "hw_labels = [\"basic\", \"decay\", \"lookahead\", \"StarPreRouting\"]\n", "\n", "fig, (ax1, ax2) = plt.subplots(\n", " 1, 2, figsize=(14, 5), gridspec_kw={\"width_ratios\": [2.5, 1]}\n", ")\n", "\n", "# Left: correlations vs distance\n", "for label in hw_labels:\n", " evs = list(hw_results[label].data.evs)\n", " b = best_circuits[label]\n", " ax1.plot(\n", " data,\n", " evs,\n", " marker=hw_markers[label],\n", " color=hw_colors[label],\n", " linewidth=2,\n", " label=f\"{label} (2Q depth={b['depth']}, size={b['size']})\",\n", " markersize=5 if label == \"StarPreRouting\" else 4,\n", " )\n", "\n", "ax1.set_xlabel(\"Distance between qubits $i$\", fontsize=11)\n", "ax1.set_ylabel(r\"$\\langle Z_0 Z_i \\rangle$\", fontsize=11)\n", "ax1.set_title(\n", " \"Entanglement correlations vs. qubit distance (hardware)\", fontsize=12\n", ")\n", "ax1.legend(fontsize=9)\n", "ax1.grid(alpha=0.3)\n", "\n", "# Right: mean fidelity bar chart\n", "hw_means = [np.mean(list(hw_results[label].data.evs)) for label in hw_labels]\n", "hw_bar_colors = [hw_colors[label] for label in hw_labels]\n", "x_bar = np.arange(len(hw_labels))\n", "bars = ax2.bar(x_bar, hw_means, color=hw_bar_colors)\n", "ax2.set_ylabel(r\"Mean $\\langle Z_0 Z_i \\rangle$\", fontsize=11)\n", "ax2.set_title(\"Average fidelity\", fontsize=13)\n", "y_range = (\n", " max(hw_means) - min(hw_means) if max(hw_means) != min(hw_means) else 0.01\n", ")\n", "ax2.set_ylim(min(hw_means) - y_range * 0.2, max(hw_means) + y_range * 0.15)\n", "for bar, val in zip(bars, hw_means):\n", " ax2.text(\n", " bar.get_x() + bar.get_width() / 2,\n", " bar.get_height() + y_range * 0.05,\n", " f\"{val:.4f}\",\n", " ha=\"center\",\n", " va=\"bottom\",\n", " fontsize=11,\n", " fontweight=\"bold\",\n", " )\n", "ax2.set_xticks(x_bar)\n", "ax2.set_xticklabels(hw_labels, fontsize=9, rotation=15)\n", "ax2.grid(axis=\"y\", linestyle=\"--\", alpha=0.5)\n", "\n", "fig.tight_layout()\n", "plt.show()\n", "\n", "print(\"\\nMean fidelity:\")\n", "for label, m in zip(hw_labels, hw_means):\n", " print(f\" {label}: {m:.4f}\")" ] }, { "cell_type": "markdown", "id": "151e5fe9-872a-4b89-92f9-85bb883de17b", "metadata": {}, "source": [ "\n", "\n", "### Análise\n", "\n", "Os gráficos de dispersão mostram uma variabilidade significativa entre as sementes para todas as três heurísticas do SABRE, o que ressalta a importância de realizar vários testes de layout, em vez de se basear em uma única transpilação. A `StarPreRouting` linha permanece essencialmente plana em todas as sementes, pois a reescrita de uma estrutura em estrela para uma cadeia linear é determinística, dada a estrutura; o roteamento SABRE posterior, portanto, tem muito pouca liberdade em uma cadeia linear, de modo que a semente quase não tem efeito sobre a profundidade ou o tamanho finais.\n", "\n", "A partir dos resultados da transpilagem, tanto a `decay` heurística quanto `lookahead` a superam consistentemente a `basic` por uma ampla margem. A `basic` heurística, embora rápida, utiliza uma estratégia gananciosa simples que muitas vezes resulta em circuitos substancialmente mais profundos. Para esse circuito GHZ com topologia em estrela, `lookahead` tende a produzir a menor profundidade de 2Q e e o menor número de portas entre as heurísticas SABRE, uma vez que sua função de custo prospectiva é bem adequada para circuitos com padrões de conectividade de longo alcance. `StarPreRouting`, No entanto, supera os três por uma margem substancial: ao reescrever a estrela em uma cadeia linear antes do roteamento, ele contorna completamente o problema de busca e gera um circuito que o restante do transpiler pode mapear para um caminho linear com um número mínimo de SWAPs adicionais.\n", "\n", "Essa vantagem se reflete diretamente na fidelidade do hardware. Uma menor profundidade de “ 2Q ” e um número menor de portas nem sempre se traduzem diretamente em maior fidelidade (os qubits físicos específicos que um layout utiliza e sua calibração em tempo de execução também são importantes), mas quando a diferença de profundidade é tão grande quanto a existente entre o SABRE e `StarPreRouting` este caso, a abordagem que leva em conta a estrutura se destaca de forma decisiva, pois o circuito acumula muito menos decoerência e muito menos eventos de erro de dois qubits. O gráfico de barras de fidelidade mostra `StarPreRouting` que está substancialmente à frente até mesmo da melhor heurística do SABRE, enquanto `basic` fica bem abaixo dos demais, pois seus circuitos, muito mais complexos, acumulam o maior número de erros.\n", "\n", "**Principais conclusões:**\n", "\n", "* Entre as heurísticas do SABRE, `decay` e `lookahead` são substancialmente melhores do que `basic` para circuitos não triviais. Opte por uma das duas opções para cargas de trabalho de produção.\n", "* A melhor heurística do SABRE depende do seu circuito e do seu hardware. Testar várias heurísticas com várias sementes é a estratégia mais confiável.\n", "* Se você quiser explorar ainda mais layouts, aumente `swap_trials` (e `layout_trials` quando não estiver definindo uma passagem de roteamento personalizada), em vez de distribuir o trabalho para nós remotos. Os passes do SABRE já paralelizam os testes entre threads locais, e o trabalho por teste é pequeno o suficiente para que a sobrecarga da distribuição normalmente supere qualquer ganho de velocidade.\n", "* Quando o circuito possui uma estrutura especial conhecida, a aplicação de uma etapa que leve em conta essa estrutura — como `StarPreRouting` antes do SABRE — pode proporcionar uma melhoria de uma ordem de magnitude que nenhum ajuste no SABRE será capaz de igualar. Isso não substitui o SABRE: `StarPreRouting` só ajuda quando o circuito realmente contém subcircuitos em estrela e o backend possui um caminho linear suficientemente longo. Vale a pena verificar se há correspondências na biblioteca de passagens sempre que você souber a forma do seu circuito.\n", "\n" ] }, { "cell_type": "markdown", "id": "65c2cebe-50b9-4304-9123-bf4cea7ecff6", "metadata": {}, "source": [ "\n", "\n", "## Próximas etapas\n", "\n", "Se você achou este trabalho interessante, talvez se interesse pelo material a seguir:\n", "\n", "\n", " * [`SabreLayout` Referência da API](/docs/api/qiskit/qiskit.transpiler.passes.SabreLayout) : documentação completa dos parâmetros\n", " * [Artigo sobre o SABRE](https://arxiv.org/abs/1809.02573) : o algoritmo SABRE original para layout e roteamento\n", " * [LightSABRE artigo](https://arxiv.org/abs/2409.08368) : as melhorias algorítmicas que sustentam a atual implementação do SABRE no Qiskit\n", " * [Escreva uma etapa personalizada do transpiler](/docs/guides/custom-transpiler-pass) : crie sua própria lógica de transpilagem\n", " * [Plug-ins de transpilação](/docs/guides/transpiler-plugins) : ampliem o pipeline de transpilação do Qiskit com etapas de terceiros\n", " * [Representação DAG](/docs/guides/DAG-representation) : compreender o grafo acíclico direcionado utilizado internamente pelo transpiler\n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "42d1c053-1683-4c32-be1b-a36602207f74", "metadata": {}, "source": [ "\n", "\n", "## Pesquisa tutorial\n", "\n", "Responda a esta breve pesquisa para fornecer feedback sobre este tutorial. Suas percepções nos ajudarão a melhorar nossas ofertas de conteúdo e a experiência do usuário.\n", "\n", "[Link para a pesquisa](https://your.feedback.ibm.com/jfe/form/SV_d9YWUSQIAvU9HXE)\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "id": "a1b8767d", "source": "© IBM Corp., 2017-2026" } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3" }, "hours": 1, "qpuSeconds": 60 }, "nbformat": 4, "nbformat_minor": 4 }