{ "cells": [ { "cell_type": "markdown", "id": "d0e7f54f-e951-44d4-8cd8-5b539cf5c91c", "metadata": {}, "source": [ "---\n", "title: \"Ejemplos de ejecutores\"\n", "description: \"Ejemplos prácticos del uso de la primitiva «Executor» en Qiskit Runtime.\"\n", "---\n", "\n", "\n", "\n", "# Ejemplos de ejecutores\n", "\n" ] }, { "cell_type": "markdown", "id": "a53ccd93-5bca-4dfb-a8a0-fcf4ed046fa7", "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", " El código de esta página se ha desarrollado teniendo en cuenta los siguientes requisitos.\n", " Recomendamos utilizar estas versiones o posteriores.\n", "\n", " ```\n", " qiskit[all]~=2.4.0\n", " qiskit-ibm-runtime~=0.46.1\n", " samplomatic~=0.18.0\n", " ```\n", " \n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "fed832ee-87a7-4261-874d-84002f3863b5", "metadata": {}, "source": [ "Los ejemplos de esta sección ilustran algunas formas habituales de utilizar la primitiva Executor. Antes de ejecutar estos ejemplos, sigue las instrucciones de [la guía de inicio rápido](/docs/guides/directed-execution-model) «[Instalación de Qiskit](/docs/guides/install-qiskit) y Executor».\n", "\n", "\n", "\n", "## Antes de empezar\n", "\n", "Algunos de los ejemplos de código de esta página utilizan `samplex`, que forma parte del paquete Samplomatic. Por lo tanto, antes de ejecutar esos bloques de código, debes instalar Samplomatic, tal y como se muestra en el siguiente bloque de código. Para obtener más información, consulta la [documentación de Samplomatic](https://qiskit.github.io/samplomatic).\n", "\n", "```python\n", "pip install samplomatic\n", "\n", "# For visualization support, include the visualization dependencies.\n", "# pip install samplomatic[vis]\n", "```\n", "\n" ] }, { "cell_type": "markdown", "id": "19549d62-4095-458d-a691-00b9bc456ed5", "metadata": {}, "source": [ "\n", "\n", "## Ejemplo: Circuito parametrizado\n", "\n", "Este ejemplo muestra cómo añadir elementos de circuito con parámetros, así como cómo añadir elementos Samplex. Consiste en los siguientes pasos:\n", "\n", "1. Configurar el circuito: Generar y transpilar el circuito de destino.\n", "2. Prepara un samplex: agrupa las puertas y las mediciones en recuadros anotados y genera la plantilla del circuito y el par de samplex.\n", "3. Ejecutar: Añadir un elemento de circuito y un elemento Samplex a un `QuantumProgram` y ejecutarlos ambos en un único trabajo.\n", "\n", "\n", "\n", "### Monta el circuito\n", "\n", "Prepara un estado GHZ de tres qubits, gira los qubits alrededor del eje de Pauli-Z y mide los qubits en la base computacional.\n", "\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "caf43d3e-ed55-4805-8d19-6c0980eeb1dc", "metadata": {}, "outputs": [], "source": [ "from qiskit.circuit import Parameter, QuantumCircuit\n", "from qiskit_ibm_runtime import QiskitRuntimeService, Executor\n", "from qiskit_ibm_runtime.quantum_program import QuantumProgram\n", "from qiskit.transpiler import generate_preset_pass_manager\n", "import numpy as np\n", "from samplomatic import build\n", "from samplomatic.transpiler import generate_boxing_pass_manager\n", "\n", "# Generate the circuit\n", "circuit = QuantumCircuit(3)\n", "circuit.h(0)\n", "circuit.h(1)\n", "circuit.cz(0, 1)\n", "circuit.h(1)\n", "circuit.h(2)\n", "circuit.cz(1, 2)\n", "circuit.h(2)\n", "circuit.rz(Parameter(\"theta\"), 0)\n", "circuit.rz(Parameter(\"phi\"), 1)\n", "circuit.rz(Parameter(\"lam\"), 2)\n", "circuit.measure_all()" ] }, { "cell_type": "markdown", "id": "f95bc53d-ed01-4b94-988b-1e497916d0fa", "metadata": {}, "source": [ "Especifica el backend y compila el circuito para que utilice únicamente instrucciones compatibles con la QPU (lo que se conoce como un circuito de arquitectura de conjunto de instrucciones, o ISA).\n", "\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "bf633f01-372f-4519-b89d-ab4075255bd9", "metadata": {}, "outputs": [], "source": [ "# Initialize the service and choose a backend\n", "service = QiskitRuntimeService()\n", "backend = service.least_busy(operational=True, simulator=False)\n", "\n", "# Transpile the circuit to ISA\n", "preset_pass_manager = generate_preset_pass_manager(\n", " backend=backend, optimization_level=3\n", ")\n", "isa_circuit = preset_pass_manager.run(circuit)" ] }, { "cell_type": "markdown", "id": "fbecf32d-d1b9-4e12-ab56-0a1ede7ebf04", "metadata": {}, "source": [ "\n", "\n", "### Prepara el samplex\n", "\n", "Utiliza la `generate_boxing_pass_manager` función de conveniencia y sus parámetros de giro para agrupar puertas de dos qubits y mediciones en recuadros y aplicar anotaciones de giro.\n", "\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "8d6d64ad-12ee-4c0c-a683-d1178600d3c7", "metadata": {}, "outputs": [], "source": [ "boxing_pm = generate_boxing_pass_manager(\n", " # Add gate twirling\n", " enable_gates=True,\n", " # Add measurement twirling\n", " enable_measures=True,\n", ")\n", "\n", "boxed_circuit = boxing_pm.run(isa_circuit)" ] }, { "cell_type": "markdown", "id": "2e8fb1f9-4b15-4161-9f8f-1c24d64b0045", "metadata": {}, "source": [ "Utiliza el `build` método para generar el circuito de referencia y el samplex.\n", "\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "90e21ca1-7f39-4636-b65e-28685b610a3c", "metadata": {}, "outputs": [], "source": [ "# Build the template circuit and the samplex\n", "template_circuit, samplex = build(boxed_circuit)" ] }, { "cell_type": "markdown", "id": "521a7263-8d2f-46fd-a261-c23ae56aa5b5", "metadata": {}, "source": [ "\n", "\n", "### Realiza los circuitos\n", "\n", "El ejecutor ejecuta `QuantumProgram` objetos. Cada uno `QuantumProgram` puede contener varios elementos. En este ejemplo se añaden un elemento de circuito y un elemento Samplex para su ejecución. Para obtener más información, consulta [la sección «Entradas y salidas del ejecutor](/docs/guides/executor-input-output) ».\n", "\n", "El primer paso consiste en inicializar un programa vacío, solicitando `1024` tomas para cada configuración de cada elemento.\n", "\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "85d7d9ef-a74c-42e4-a758-0f490e29275d", "metadata": {}, "outputs": [], "source": [ "# Generate a quantum program\n", "program = QuantumProgram(shots=1024)" ] }, { "cell_type": "markdown", "id": "8869d18d-cc0e-4556-a195-cd6b590bcef7", "metadata": {}, "source": [ "Añade el elemento del circuito al `QuantumProgram`. Este elemento del circuito consta de dos partes: el circuito ISA y 10 conjuntos de valores de sus parámetros.\n", "\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "19963674-3e72-473c-b24a-228316946dc5", "metadata": {}, "outputs": [], "source": [ "# Append the circuit and the parameter values to the program\n", "program.append_circuit_item(\n", " isa_circuit,\n", " circuit_arguments=np.random.rand(10, 3), # 10 sets of parameter values\n", ")" ] }, { "cell_type": "markdown", "id": "41505f83-a7a6-4ea8-a7fc-a3fb45a2992a", "metadata": {}, "source": [ "`QuantumProgram` Añade el elemento «samplex» a con estos argumentos:\n", "\n", "* El circuito de plantilla y el samplex generado por la `build` función\n", "* Diez conjuntos de valores de parámetros para el circuito original\n", "* El número de aleatorizaciones que hay que realizar\n", "\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "d6b07700-5834-4baa-a08a-434516f5bc07", "metadata": {}, "outputs": [], "source": [ "# Append the template circuit and samplex as a samplex item\n", "program.append_samplex_item(\n", " template_circuit,\n", " samplex=samplex,\n", " samplex_arguments={\n", " \"parameter_values\": np.random.rand(\n", " 10, 3\n", " ), # 10 sets of parameter values\n", " },\n", " shape=(2, 14, 10),\n", ")" ] }, { "cell_type": "markdown", "id": "f39e3e78-5953-4801-b521-dd48ae487acf", "metadata": {}, "source": [ "\n", "\n", "### Ejecuta la tarea de Executor\n", "\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "149addb2-e76f-427c-bac4-54b6a83ddb0a", "metadata": {}, "outputs": [], "source": [ "# initialize an Executor with default options\n", "executor = Executor(mode=backend)\n", "\n", "# Submit the job\n", "job = executor.run(program)\n", "\n", "# Retrieve the result\n", "result = job.result()" ] }, { "cell_type": "markdown", "id": "93698fec-cff7-4153-8cbb-f7e39c972d9a", "metadata": {}, "source": [ "Obtén el resultado de cada tarea.\n", "\n" ] }, { "cell_type": "code", "execution_count": 9, "id": "77235bf8-bcac-43fb-89b0-9ba74b976053", "metadata": {}, "outputs": [], "source": [ "# Access the results of the classical register of task #0, the CircuitItem\n", "result_0 = result[0][\"meas\"]\n", "\n", "# Access the results of the classical register of task #1, the SamplexItem\n", "result_1 = result[1][\"meas\"]" ] }, { "cell_type": "markdown", "id": "64063941-87b5-4c5d-bbf9-8920c24a216f", "metadata": {}, "source": [ "\n", "\n", "## Ejemplo: Realizar PEC\n", "\n", "Este ejemplo muestra cómo utilizar un elemento «samplex» para llevar a cabo la cancelación probabilística de errores ( [PEC](/docs/guides/error-mitigation-and-suppression-techniques#pec) ) con el fin de mitigar los errores.\n", "\n", "Consideremos una versión simétrica de un circuito con diez qubits y dos capas distintas de puertas CX. Estas son las tareas principales:\n", "\n", "* Realiza el circuito con giros.\n", "* Ejecuta el circuito con mitigación PEC, tal y como se describe en el artículo [«Probabilistic error cancellation with sparse Pauli-Lindblad models on noisy quantum processors](https://arxiv.org/abs/2201.09866) ».\n", "\n", "El proceso consta de los siguientes pasos:\n", "\n", "1. Configuración: Genera el circuito de destino y agrupa sus operaciones en recuadros.\n", "2. Aprender: Identificar el ruido de las instrucciones que queremos mitigar con PEC.\n", "3. Ejecutar: Ejecuta el circuito en un servidor.\n", "4. Analizar: Procesar y analizar los resultados.\n", "\n", "A modo de comparación, ejecutaremos este circuito simétrico dos veces. Una vez aplicando únicamente el efecto de Pauli, y otra vez aplicando la corrección PEC.\n", "\n", "\n", " La duración de este ejemplo es de unos 10 minutos en un procesador Heron r2.\n", "\n", "\n", "\n", "\n", "### Monta el circuito\n", "\n", "Elige un backend y prepara un circuito de 10 qubits.\n", "\n" ] }, { "cell_type": "code", "execution_count": 10, "id": "f9e93b2c-154a-4d09-872d-f770bcc669c4", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit_ibm_runtime import QiskitRuntimeService, Executor\n", "from qiskit_ibm_runtime.quantum_program import QuantumProgram\n", "from qiskit.circuit import QuantumCircuit, Parameter\n", "from qiskit.transpiler import generate_preset_pass_manager\n", "from samplomatic.transpiler import generate_boxing_pass_manager\n", "from samplomatic import build\n", "\n", "# Initialize the service and choose a backend\n", "service = QiskitRuntimeService()\n", "backend = service.least_busy(operational=True, simulator=False)\n", "\n", "# Prepare a circuit\n", "\n", "num_qubits = 10\n", "num_layers = 10\n", "\n", "qubits = list(range(num_qubits))\n", "circuit = QuantumCircuit(num_qubits)\n", "\n", "for layer_idx in range(num_layers):\n", " circuit.rx(Parameter(f\"theta_{layer_idx}\"), qubits)\n", " for i in range(num_qubits // 2):\n", " circuit.cz(qubits[2 * i], qubits[2 * i + 1])\n", "\n", " circuit.rx(Parameter(f\"phi_{layer_idx}\"), qubits)\n", " for i in range(num_qubits // 2 - 1):\n", " circuit.cz(qubits[2 * i] + 1, qubits[2 * i + 1] + 1)\n", "\n", "circuit.draw(\"mpl\", scale=0.35, fold=100)" ] }, { "cell_type": "markdown", "id": "2d76f4f5-48b7-4123-8b6b-32eeaa06527d", "metadata": {}, "source": [ "Combina el circuito con su inverso para crear un circuito especular.\n", "\n" ] }, { "cell_type": "code", "execution_count": 11, "id": "f8ac3f75-88ca-40f9-8382-6a427303bb8e", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "mirror_circuit = circuit.compose(circuit.inverse())\n", "mirror_circuit.measure_all()\n", "\n", "mirror_circuit.draw(\"mpl\", scale=0.35, fold=100)" ] }, { "cell_type": "markdown", "id": "2bb0692c-3d4f-4a74-807e-6b93ef4ea8d2", "metadata": {}, "source": [ "Establece algunos valores de los parámetros:\n", "\n" ] }, { "cell_type": "code", "execution_count": 12, "id": "c1974bff-c738-43a8-8e27-b85059e2428a", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "\n", "parameter_values = np.random.rand(mirror_circuit.num_parameters)" ] }, { "cell_type": "markdown", "id": "0ca9f203-008b-4190-9e86-affefb303938", "metadata": {}, "source": [ "Utiliza el gestor de pases para transpilar el circuito y convertirlo en un circuito ISA.\n", "\n" ] }, { "cell_type": "code", "execution_count": 13, "id": "224e0d6d-9238-4fae-aad8-f051c7e34938", "metadata": {}, "outputs": [], "source": [ "preset_pass_manager = generate_preset_pass_manager(\n", " backend=backend,\n", " optimization_level=3,\n", ")\n", "\n", "isa_circuit = preset_pass_manager.run(mirror_circuit)" ] }, { "cell_type": "markdown", "id": "9dd71644-df3d-4cf3-9e4b-9c7624b54961", "metadata": {}, "source": [ "A continuación, agrupa las puertas y las mediciones en recuadros con anotaciones. Puedes hacerlo manualmente o, si lo prefieres, utilizar la `generate_boxing_pass_manager` función de Samplomatic. Al primer circuito solo se le aplicará el efecto de giro, por lo que solo necesita la `Twirl` anotación. El segundo circuito se ejecutará con mitigación PEC completa y requiere las `Twirl` anotaciones y `InjectNoise` .\n", "\n" ] }, { "cell_type": "code", "execution_count": 14, "id": "4afb22f1-b41f-40ed-87f7-c2d0b0f6730c", "metadata": {}, "outputs": [], "source": [ "# Pass manager used to create twirled-annotated boxes.\n", "boxing_pm = generate_boxing_pass_manager(\n", " enable_gates=True,\n", " enable_measures=True,\n", ")\n", "\n", "mirror_circuit_twirl = boxing_pm.run(isa_circuit)\n", "\n", "# Pass manager used to create a new boxed circuit with\n", "# both Twirl and InjectNoise annotations.\n", "boxing_pm = generate_boxing_pass_manager(\n", " enable_gates=True,\n", " enable_measures=True,\n", " inject_noise_targets=\"gates\", # no measurement mitigation\n", " inject_noise_strategy=\"uniform_modification\",\n", ")\n", "\n", "mirror_circuit_pec = boxing_pm.run(isa_circuit)" ] }, { "cell_type": "markdown", "id": "bd0c7cc5-48ba-47ab-84bc-41f832af3d8d", "metadata": {}, "source": [ "\n", "\n", "### Aprende a reconocer el ruido\n", "\n", "Para reducir al mínimo el número de experimentos de aprendizaje con ruido, identifica las instrucciones únicas del segundo circuito (el que tiene casillas marcadas con `InjectNoise`). A la hora de definir la unicidad, dos instrucciones de cuadro se consideran iguales si se cumplen las dos condiciones siguientes:\n", "\n", "* Su contenido es idéntico, salvo por las puertas de un solo qubit.\n", "* Su `Twirl` anotación es igual (se ignoran todas las demás anotaciones).\n", "\n", "Esto da lugar a tres instrucciones específicas: las casillas de puertas pares e impares y la casilla de medición final.\n", "\n" ] }, { "cell_type": "code", "execution_count": 15, "id": "2f8b325a-ffa4-447a-bf32-8b26b7404b0a", "metadata": {}, "outputs": [], "source": [ "from samplomatic.utils import find_unique_box_instructions\n", "\n", "unique_box_instructions = find_unique_box_instructions(\n", " mirror_circuit_pec.data\n", ")\n", "assert len(unique_box_instructions) == 3" ] }, { "cell_type": "markdown", "id": "7d496c90-fb07-49e6-a233-451ad4306102", "metadata": {}, "source": [ "`NoiseLearnerV3`Inicialice un proceso, seleccione los parámetros de aprendizaje configurando sus opciones y ejecute una tarea de aprendizaje de ruido.\n", "\n" ] }, { "cell_type": "code", "execution_count": 16, "id": "d69204bb-4beb-4b31-b9dd-e8923889685e", "metadata": {}, "outputs": [], "source": [ "from qiskit_ibm_runtime.noise_learner_v3 import NoiseLearnerV3\n", "\n", "learner = NoiseLearnerV3(backend)\n", "\n", "learner.options.shots_per_randomization = 128\n", "learner.options.num_randomizations = 32\n", "learner.options.layer_pair_depths = [0, 1, 2, 4, 16, 32]\n", "\n", "learner_job = learner.run(unique_box_instructions)\n", "\n", "learner_job.job_id()\n", "learner_result = learner_job.result()" ] }, { "cell_type": "markdown", "id": "efe80acb-f12d-4051-84ed-d61a5a93ca23", "metadata": {}, "source": [ "Convierte `result` el objeto al formato requerido por el samplex utilizando el `result.to_dict` método.\n", "\n" ] }, { "cell_type": "code", "execution_count": 17, "id": "fd63ad99-01ad-492b-9232-91f2377f97f6", "metadata": {}, "outputs": [], "source": [ "noise_maps = learner_result.to_dict(\n", " instructions=unique_box_instructions, require_refs=False\n", ")" ] }, { "cell_type": "markdown", "id": "89dd2022-db07-46f6-8737-644aa070dcdb", "metadata": {}, "source": [ "\n", "\n", "### Realiza los circuitos\n", "\n", "`Executor` ejecuta `QuantumProgram` objetos. Cada uno `QuantumProgram` puede contener varios *elementos*, que se añaden al programa. Cada elemento es una tarea que debe realizar el programa.\n", "\n", "Inicia un programa vacío que solicite `1000` imágenes para cada configuración de cada elemento.\n", "\n" ] }, { "cell_type": "code", "execution_count": 18, "id": "b48b038e-6e7d-4a6a-8f9a-df1389b644fa", "metadata": {}, "outputs": [], "source": [ "from qiskit_ibm_runtime.quantum_program import QuantumProgram\n", "\n", "# Initialize an empty QuantumProgram\n", "program = QuantumProgram(shots=1000)" ] }, { "cell_type": "markdown", "id": "845a9fdb-6837-4bda-925c-8795613bb708", "metadata": {}, "source": [ "A continuación, crea el circuito de plantilla y el samplex para `mirror_circuit_twirl` y añádelos al programa. Solicita `900` también aleatorizaciones del conjunto de muestras. Esto significa que el samplex generará `900` conjuntos de parámetros, y cada conjunto se ejecutará `1000` un número de veces (el número de iteraciones) en la QPU.\n", "\n", "Esta es la primera tarea del programa (resultado 0).\n", "\n" ] }, { "cell_type": "code", "execution_count": 19, "id": "38942fab-f68d-44ed-b613-362b38a1ca02", "metadata": {}, "outputs": [], "source": [ "template_twirl, samplex_twirl = build(mirror_circuit_twirl)\n", "\n", "program.append_samplex_item(\n", " template_twirl,\n", " samplex=samplex_twirl,\n", " samplex_arguments={\"parameter_values\": parameter_values},\n", " shape=(900,),\n", ")" ] }, { "cell_type": "markdown", "id": "a30d1536-5339-4f19-b351-1c26891a4817", "metadata": {}, "source": [ "Del mismo modo, añade el circuito de plantilla y el samplex creados para `mirror_circuit_pec`, solicitando `900` aleatorizaciones. Esta es la segunda tarea del programa (resultado 1).\n", "\n" ] }, { "cell_type": "code", "execution_count": 20, "id": "16bbb410-b0b7-4011-b4d0-62ffbad30f41", "metadata": {}, "outputs": [], "source": [ "template_pec, samplex_pec = build(mirror_circuit_pec)\n", "\n", "program.append_samplex_item(\n", " template_pec,\n", " samplex=samplex_pec,\n", " samplex_arguments={\n", " \"parameter_values\": parameter_values,\n", " \"pauli_lindblad_maps\": noise_maps,\n", " \"noise_scales\": {\n", " ref: -1.0 for ref in noise_maps\n", " }, # Set the scales to -1 for PEC\n", " },\n", " shape=(900,),\n", ")" ] }, { "cell_type": "markdown", "id": "abf9d679-0262-4447-b889-9b06ad3cd77d", "metadata": {}, "source": [ "Importar `Executor` y enviar un trabajo.\n", "\n" ] }, { "cell_type": "code", "execution_count": 21, "id": "6231e441-87f4-480a-886a-5fdd83631e60", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Twirl result keys:\n", " ['meas', 'measurement_flips.meas']\n", "\n", "Shape of results: (900, 1000, 10)\n", "PEC result keys:\n", " ['meas', 'measurement_flips.meas', 'pauli_signs']\n", "\n", "Shape of results: (900, 1000, 10)\n" ] } ], "source": [ "from qiskit_ibm_runtime.executor import Executor\n", "\n", "executor = Executor(backend)\n", "executor_job = executor.run(program)\n", "\n", "executor_job.job_id()\n", "\n", "executor_results = executor_job.result()\n", "executor_results\n", "\n", "twirl_result = executor_results[0]\n", "\n", "print(f\"Twirl result keys:\\n {list(twirl_result.keys())}\\n\")\n", "print(f\"Shape of results: {twirl_result['meas'].shape}\")\n", "\n", "pec_result = executor_results[1]\n", "\n", "print(f\"PEC result keys:\\n {list(pec_result.keys())}\\n\")\n", "print(f\"Shape of results: {pec_result['meas'].shape}\")" ] }, { "cell_type": "markdown", "id": "021b944c-5119-4554-b4e9-2af1cfc906d8", "metadata": {}, "source": [ "\n", "\n", "### Analizar los resultados\n", "\n", "Por último, procesa los resultados para estimar los valores esperados de los operadores Pauli-Z de un solo qubit que actúan sobre cada uno de los diez qubits activos (valor esperado: `1.0`).\n", "\n" ] }, { "cell_type": "code", "execution_count": 22, "id": "a24c1dd9-7f29-40b0-87ad-25c2a03e0431", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Qubit 0 -> 0.77\n", "Qubit 1 -> 0.76\n", "Qubit 2 -> 0.66\n", "Qubit 3 -> 0.71\n", "Qubit 4 -> 0.69\n", "Qubit 5 -> 0.67\n", "Qubit 6 -> 0.62\n", "Qubit 7 -> 0.59\n", "Qubit 8 -> 0.62\n", "Qubit 9 -> 0.68\n" ] } ], "source": [ "# Undo measurement twirling\n", "twirl_result_unflipped = (\n", " twirl_result[\"meas\"] ^ twirl_result[\"measurement_flips.meas\"]\n", ")\n", "\n", "# Calculate the expectation values of single-qubit Z operators\n", "exp_vals = 1 - 2 * twirl_result_unflipped.mean(axis=1).mean(axis=0)\n", "\n", "for qubit, val in enumerate(exp_vals):\n", " print(f\"Qubit {qubit} -> {np.round(val, 2)}\")" ] }, { "cell_type": "code", "execution_count": 23, "id": "8aa25d47-c4fd-4b20-a36f-fa69d7bd0971", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Qubit 0 -> 0.98\n", "Qubit 1 -> 0.99\n", "Qubit 2 -> 0.96\n", "Qubit 3 -> 0.98\n", "Qubit 4 -> 0.98\n", "Qubit 5 -> 0.98\n", "Qubit 6 -> 0.98\n", "Qubit 7 -> 0.95\n", "Qubit 8 -> 0.95\n", "Qubit 9 -> 0.94\n" ] } ], "source": [ "# Undo measurement twirling\n", "pec_result_unflipped = (\n", " pec_result[\"meas\"] ^ pec_result[\"measurement_flips.meas\"]\n", ")\n", "\n", "# Calculate the signs for PEC mitigation\n", "signs = np.prod((-1) ** pec_result[\"pauli_signs\"], axis=-1)\n", "signs = signs.reshape((signs.shape[0], 1))\n", "\n", "# Calculate the expectation values of single-qubit Z operators as required by\n", "# PEC mitigation\n", "exp_vals = 1 - (2 * pec_result_unflipped.mean(axis=1) * signs).mean(axis=0)\n", "\n", "for qubit, val in enumerate(exp_vals):\n", " print(f\"Qubit {qubit} -> {np.round(val, 2)}\")" ] }, { "cell_type": "markdown", "id": "cf25d17a-5e90-4e24-a3bf-c86f5bc3444b", "metadata": {}, "source": [ "\n", "\n", "## Próximos pasos\n", "\n", "\n", " * Consulte la descripción general [de la emisión](/docs/guides/primitive-input-output#broadcasting).\n", " * Aprende a utilizar [las opciones](/docs/guides/executor-options) de Executor.\n", " * Comprender el [modelo de ejecución dirigida](/docs/guides/directed-execution-model).\n", " * Consulta la [documentación de Samplomatic](https://qiskit.github.io/samplomatic/).\n", " * Descubre cómo combinar diferentes técnicas de mitigación de errores al utilizar el modelo de ejecución dirigida en el tutorial «[Cancelación probabilística de errores con conos de luz sombreados](https://qiskit.github.io/qiskit-addon-slc/tutorials/01_getting_started.html) ».\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": 4 }