{ "cells": [ { "cell_type": "markdown", "id": "3e0865c2", "metadata": {}, "source": [ "---\n", "title: \"Utilizar a pós-seleção em cargas de trabalho\"\n", "description: \"Entenda como integrar a pós-seleção à sua estratégia de mitigação de erros\"\n", "---\n", "\n", "\n", "\n", "# Utilizar a pós-seleção em cargas de trabalho\n", "\n" ] }, { "cell_type": "markdown", "id": "23b642e2", "metadata": { "tags": [ "version-info" ] }, "source": [ "{/*\n", " DO NOT EDIT THIS CELL!!!\n", " This cell's content is generated automatically by a script. Anything you add\n", " here will be removed next time the notebook is run. To add new content, create\n", " a new cell before or after this one.\n", " */}\n", "\n", "\n", " \n", " O código desta página foi desenvolvido com base nos seguintes requisitos.\n", " Recomendamos o uso dessas versões ou versões mais recentes.\n", "\n", " ```\n", " qiskit[all]~=2.5.1\n", " qiskit-ibm-runtime~=0.47.0\n", " qiskit-addon-utils~=0.4.0\n", " ```\n", " \n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "b042e4d5", "metadata": {}, "source": [ "Ao otimizar a estratégia de mitigação de erros de uma carga de trabalho, muitas vezes é útil filtrar as medições que se sabe terem sido contaminadas por processos de ruído não markovianos (correlacionados). Um desses métodos consiste em adicionar ao circuito uma etapa de pós-processamento que mede os qubits ativos e os qubits “espectadores” adjacentes, aplica uma rotação lenta a cada qubit e, em seguida, os mede novamente. Nos casos em que as duas medições não confirmam a inversão do qubit, conforme esperado, a medição é descartada por meio da aplicação de uma máscara aos resultados.\n", "\n", "O pacote [de utilitários do complemento Qiskit](https://qiskit.github.io/qiskit-addon-utils/) oferece um conjunto de etapas de transpilador e uma função de pós-seleção para aplicar a máscara. Esta página oferece orientações sobre como incorporar a pós-seleção em suas cargas de trabalho quânticas, utilizando como exemplo um estado GHZ de quatro qubits.\n", "\n" ] }, { "cell_type": "markdown", "id": "a645f8ff", "metadata": {}, "source": [ "\n", "\n", "## CREATE WORKLOAD\n", "\n", "Comece preparando o circuito para ser executado e compilado para um backend que suporte portas fracionárias.\n", "\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "68fa9100", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit_ibm_runtime import QiskitRuntimeService\n", "from qiskit.circuit import QuantumCircuit\n", "from qiskit.transpiler import generate_preset_pass_manager\n", "\n", "circuit = QuantumCircuit(4)\n", "circuit.h(0)\n", "circuit.cx(0, 1)\n", "circuit.cx(1, 2)\n", "circuit.cx(2, 3)\n", "circuit.measure_all()\n", "\n", "\n", "service = QiskitRuntimeService()\n", "backend = service.least_busy(use_fractional_gates=True)\n", "pm = generate_preset_pass_manager(optimization_level=3, backend=backend)\n", "\n", "transpiled_circuit = pm.run(circuit)\n", "transpiled_circuit.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "5adeb935", "metadata": {}, "source": [ "\n", "\n", "## Adicionar etapas de transpilador de pós-seleção\n", "\n", "Em seguida, crie um gerenciador de passagens predefinido que inclua as [`AddPostSelectionMeasures`](https://qiskit.github.io/qiskit-addon-utils/stubs/qiskit_addon_utils.noise_management.post_selection.transpiler.passes.AddSpectatorMeasures.html) passagens e [`AddSpectatorMeasures`](https://qiskit.github.io/qiskit-addon-utils/stubs/qiskit_addon_utils.noise_management.post_selection.transpiler.passes.AddPostSelectionMeasures.html) do [`qiskit-addon-utils`](https://qiskit.github.io/qiskit-addon-utils/index.html) pacote. Isso acrescentará ao circuito uma sequência de rotações de ângulo `RX` pequeno (produzindo, na prática, um portão longo `X` ), juntamente com um segundo conjunto de medições.\n", "\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "faf50950", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.transpiler import PassManager\n", "from qiskit_addon_utils.noise_management.post_selection import PostSelector\n", "from qiskit_addon_utils.noise_management.post_selection.transpiler.passes import (\n", " AddPostSelectionMeasures,\n", " AddSpectatorMeasures,\n", ")\n", "\n", "\n", "post_selection_pm = PassManager(\n", " [\n", " AddSpectatorMeasures(backend.coupling_map, add_barrier=True),\n", " AddPostSelectionMeasures(x_pulse_type=\"rx\"),\n", " ]\n", ")\n", "\n", "template_circuit_ps = post_selection_pm.run(transpiled_circuit)\n", "template_circuit_ps.draw(\"mpl\", fold=-1, idle_wires=False)" ] }, { "cell_type": "markdown", "id": "e0fdf29d", "metadata": {}, "source": [ "\n", "\n", "## Executar programa quântico\n", "\n", "Em seguida, prepare um `QuantumProgram` objeto que contenha o circuito a ser executado.\n", "\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "649aef44", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Job ID: d9mqa4fbupns73e942q0\n" ] } ], "source": [ "from qiskit_ibm_runtime import QuantumProgram, Executor\n", "\n", "shots = 4000\n", "\n", "program = QuantumProgram(shots=shots)\n", "program.append_circuit_item(template_circuit_ps)\n", "\n", "# Initialize the Executor job and run\n", "executor = Executor(backend)\n", "executor_job = executor.run(program)\n", "print(f\"Job ID: {executor_job.job_id()}\")" ] }, { "cell_type": "markdown", "id": "4068dd8f", "metadata": {}, "source": [ "Agora você pode interpretar os resultados. O resultado da execução é um dicionário com várias chaves.\n", "\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "64f52429", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "KeysView(QuantumProgramItemResult({'meas': array([[False, False, False, False],\n", " [ True, True, True, True],\n", " [False, False, False, False],\n", " ...,\n", " [ True, True, True, True],\n", " [ True, True, True, True],\n", " [False, False, False, False]], shape=(4000, 4)), 'spec': array([[False, False, False, False],\n", " [False, False, False, False],\n", " [False, False, False, False],\n", " ...,\n", " [False, False, False, False],\n", " [False, False, False, False],\n", " [False, False, False, False]], shape=(4000, 4)), 'meas_ps': array([[ True, True, True, True],\n", " [False, False, False, False],\n", " [ True, True, True, True],\n", " ...,\n", " [False, False, True, False],\n", " [False, False, False, False],\n", " [ True, True, True, True]], shape=(4000, 4)), 'spec_ps': array([[ True, True, True, True],\n", " [ True, True, True, True],\n", " [ True, True, False, True],\n", " ...,\n", " [ True, True, True, True],\n", " [ True, True, True, True],\n", " [ True, True, True, True]], shape=(4000, 4))}, metadata=ItemMetadata()))" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "executor_result = executor_job.result()[0]\n", "executor_result.keys()" ] }, { "cell_type": "markdown", "id": "6b460888", "metadata": {}, "source": [ "Essas chaves correspondem aos qubits ativo e espectador antes das `rx` instruções (`meas` e `spec`) e após as `rx` instruções (`meas_ps` e `spec_ps`). Cada um deles é uma matriz de matrizes, com base no número de disparos e qubits. Nesse caso, a forma é (1000, 4).\n", "\n", "\n", "\n", "## Criar máscara de pós-seleção\n", "\n", "A partir dessas medidas, você pode criar uma máscara usando a [`PostSelector`](https://qiskit.github.io/qiskit-addon-utils/apidocs/qiskit_addon_utils.noise_management.html#qiskit_addon_utils.noise_management.PostSelector) classe de `qiskit-addon-utils`. Esta máscara é uma matriz booleana na qual cada quadro é marcado como ou `False``True` com base em uma das duas estratégias de pós-seleção. A primeira estratégia `node`utiliza informações do qubit para decidir se uma tentativa de medição deve ser descartada — e a segunda `edge`utiliza informações de conectividade entre vizinhos mais próximos para tomar essa decisão.\n", "\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "299d460d", "metadata": {}, "outputs": [], "source": [ "post_selector = PostSelector.from_circuit(\n", " circuit=template_circuit_ps, coupling_map=backend.coupling_map\n", ")\n", "\n", "mask_node = post_selector.compute_mask(executor_result, strategy=\"node\")\n", "mask_edge = post_selector.compute_mask(executor_result, strategy=\"edge\")" ] }, { "cell_type": "markdown", "id": "023cb624", "metadata": {}, "source": [ "Tanto a estratégia de nós quanto a de arestas costumam descartar jogadas diferentes. Você pode escolher qualquer uma delas. Este caderno utiliza uma operação AND bit a bit, que é uma estratégia conservadora que mantém uma tentativa apenas se ela for aprovada tanto pela estratégia de nós quanto pela estratégia de arestas.\n", "\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "5ec9bc4a", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The combined mask: [ True True False ... False True True]\n", "Percentage of the shots retained is after post selection 70.35\n" ] } ], "source": [ "mask = mask_node & mask_edge\n", "print(f\"The combined mask: {mask}\")\n", "count_retained = 0\n", "\n", "for m in mask:\n", " count_retained += m\n", "\n", "print(\n", " f\"Percentage of the shots retained is after post selection \"\n", " f\"{100 * count_retained / shots}\"\n", ")" ] }, { "cell_type": "markdown", "id": "77a9c1af", "metadata": {}, "source": [ "Compare a distribuição de probabilidade com e sem pós-seleção. O trecho de código a seguir calcula a distribuição de probabilidade antes e depois da pós-seleção, bem como a distância entre as distribuições medida e ideal.\n", "\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "43704cfc", "metadata": {}, "outputs": [], "source": [ "counts = {}\n", "counts_ps = {}\n", "\n", "\n", "for idx, measurement in enumerate(executor_result[\"meas\"]):\n", " bitstring = \"\"\n", " for bit in measurement:\n", " bitstring += str(int(bit))\n", "\n", " if bitstring in counts:\n", " counts[bitstring] += 1\n", " else:\n", " counts[bitstring] = 1\n", "\n", " # Compute count data for postselected shots based on the mask\n", " if mask[idx]:\n", " bitstring = \"\"\n", " for bit in measurement:\n", " bitstring += str(int(bit))\n", "\n", " if bitstring in counts_ps:\n", " counts_ps[bitstring] += 1\n", " else:\n", " counts_ps[bitstring] = 1\n", "\n", "for key, val in counts.items():\n", " counts[key] = val / shots\n", "\n", "\n", "for key, val in counts_ps.items():\n", " counts_ps[key] = float(val / count_retained)" ] }, { "cell_type": "markdown", "id": "16551af2", "metadata": {}, "source": [ "Para demonstrar como a pós-seleção alterou seus resultados, calcule a distância entre a distribuição de probabilidade ideal e as distribuições medidas.\n", "\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "b1ba31b9", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Distance from ideal distribution before postselection: 0.95225\n", "Distance from ideal distribution before after-selection: 0.939587775408671\n" ] }, { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import itertools\n", "from qiskit.visualization import plot_histogram\n", "\n", "bitstrings = [\"\".join(i) for i in itertools.product(\"01\", repeat=4)]\n", "counts_ideal = {}\n", "for bitstring in bitstrings:\n", " counts_ideal[bitstring] = 0.0\n", "counts_ideal[\"1111\"] = 0.5\n", "counts_ideal[\"0000\"] = 0.5\n", "\n", "\n", "prob_distance = 0.0\n", "prob_distance_ps = 0.0\n", "\n", "for bitstring in counts_ideal.keys():\n", " dist = 0.0\n", " dist_ps = 0.0\n", " if bitstring in counts:\n", " dist = abs(counts[bitstring] - counts_ideal[bitstring])\n", " if bitstring in counts_ps:\n", " dist_ps = abs(counts_ps[bitstring] - counts_ideal[bitstring])\n", " prob_distance += dist\n", " prob_distance_ps += dist_ps\n", "\n", "\n", "print(\n", " f\"Distance from ideal distribution before postselection: \"\n", " f\"{1-prob_distance*0.5}\"\n", ")\n", "print(\n", " f\"Distance from ideal distribution before after-selection: \"\n", " f\"{1-prob_distance_ps*0.5}\"\n", ")\n", "\n", "\n", "plot_histogram([counts, counts_ps], legend=[\"Normal\", \"Post selected\"])" ] }, { "cell_type": "markdown", "id": "c205afea", "metadata": {}, "source": [ "Embora a pós-seleção possa melhorar significativamente a qualidade dos resultados ao filtrar as medições de resultados afetadas por ruído não markoviano, ela não constitui, por si só, uma solução completa para a mitigação de erros. A pós-seleção reduz o impacto de certos erros ao descartar resultados de medição inválidos, mas isso acarreta um aumento na sobrecarga da amostragem e não resolve todos os mecanismos de erro presentes no hardware quântico de curto prazo. Consequentemente, é provável que não seja suficiente basear-se exclusivamente na pós-seleção para circuitos mais complexos ou mais profundos. Em vez disso, a pós-seleção é mais eficaz quando utilizada como parte de uma estratégia mais ampla de mitigação de erros — complementando técnicas como a mitigação de erros de medição, a compilação de circuitos sensíveis ao ruído ou o cancelamento probabilístico de erros — para melhorar a confiabilidade das cargas de trabalho quânticas, ao mesmo tempo em que equilibra a precisão e o custo dos recursos.\n", "\n", "\n", "\n", "## Próximas etapas\n", "\n", "\n", " * Entenda como incorporar [o aprendizado com ruído](/docs/guides/noise-learning) em uma carga de trabalho quântica.\n", " * Leia sobre outras técnicas disponíveis [de mitigação e supressão de erros](/docs/guides/error-mitigation-and-suppression-techniques).\n", " * Aprenda a usar [códigos espaço-temporais](/docs/tutorials/spacetime-codes) para uma abordagem de baixa sobrecarga na detecção de erros\n", "\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" } }, "nbformat": 4, "nbformat_minor": 5 }