{ "cells": [ { "cell_type": "markdown", "id": "24576595", "metadata": {}, "source": [ "---\n", "title: \"Núcleos cuánticos con puertas fraccionarias\"\n", "description: \"Utilizar puertas fraccionarias —puertas parametrizadas que ejecutan directamente rotaciones de ángulo arbitrario— para reducir la profundidad y la duración de los circuitos de núcleo cuántico.\"\n", "---\n", "\n", "\n", "\n", "# Núcleos cuánticos con puertas fraccionarias\n", "\n", "*Estimación de uso: menos de 30 segundos en un procesador Heron r2 (NOTA: Esto es sólo una estimación. Su tiempo de ejecución puede variar)*\n", "\n" ] }, { "cell_type": "markdown", "id": "983da41e", "metadata": {}, "source": [ "\n", "\n", "## Resultados del aprendizaje\n", "\n", "Una vez que hayas completado este tutorial, deberías haber comprendido lo siguiente:\n", "\n", "* Qué son las puertas fraccionarias y cómo reducen la profundidad y la duración de los circuitos en las QPU de IBM®\n", "* Las limitaciones asociadas al uso de puertas fraccionarias (en concreto, el rango de ángulos RZZ)\n", "* Cómo crear un flujo de trabajo de «quantum kernel» que utilice puertas fraccionarias con « Qiskit Runtime »\n", "* Cómo comparar métricas de ejecución en hardware (profundidad, duración, recuento de puertas no locales, fidelidad) con y sin puertas fraccionarias\n", "* Cómo utilizar únicamente puertas RX fraccionarias sin alterar el flujo de trabajo estándar de Qiskit Patterns\n", "\n", "\n", "\n", "## Requisitos previos\n", "\n", "Te recomendamos que te familiarices con los siguientes temas antes de seguir este tutorial:\n", "\n", "* El flujo de trabajo de [Qiskit Patterns](/docs/guides/intro-to-patterns)\n", "* Guía sobre [las puertas fraccionarias](/docs/guides/fractional-gates)\n", "* El tutorial [de formación sobre kernels cuánticos](/docs/tutorials/quantum-kernel-training) y la lección [sobre kernels cuánticos](/learning/courses/quantum-machine-learning/quantum-kernel-methods) del curso de aprendizaje automático cuántico\n", "\n" ] }, { "cell_type": "markdown", "id": "155eab76", "metadata": {}, "source": [ "\n", "\n", "## En segundo plano\n", "\n", "\n", "\n", "### Puertas fraccionarias en QPU de IBM\n", "\n", "Las puertas fraccionarias son puertas cuánticas parametrizadas que permiten la ejecución directa de rotaciones de ángulo arbitrario (dentro de unos límites específicos),\n", "lo que elimina la necesidad de descomponerlas en varias puertas básicas.\n", "Al aprovechar las interacciones nativas entre los qubits físicos, es posible implementar ciertos operadores unitarios de forma más eficiente en el hardware.\n", "\n", "IBM Las QPUs Quantum® Heron admiten las siguientes puertas fraccionarias:\n", "\n", "* $R_{ZZ}(\\theta)$ para $0 < \\theta < \\pi / 2$\n", "* $R_X(\\theta)$ para cualquier valor real $\\theta$\n", "\n", "Estas puertas pueden reducir significativamente tanto la profundidad como la duración de los circuitos cuánticos.\n", "Son especialmente ventajosos en aplicaciones que dependen en gran medida de $R_{ZZ}$ y $R_X$, como la simulación hamiltoniana, el algoritmo de optimización aproximada cuántica (QAOA) y los métodos de núcleo cuántico.\n", "En este tutorial, nos centraremos en el núcleo cuántico como ejemplo práctico.\n", "\n" ] }, { "cell_type": "markdown", "id": "fe5675f3", "metadata": {}, "source": [ "\n", "\n", "### Limitaciones\n", "\n", "Las puertas fraccionarias son actualmente una función experimental y tienen algunas limitaciones:\n", "\n", "* $R_{ZZ}$ se limita a ángulos en el rango $0 < \\theta < \\pi / 2$.\n", "* El uso de puertas fraccionarias no es compatible con [circuitos dinámicos](/docs/guides/classical-feedforward-and-control-flow), [giro de Pauli](/docs/guides/error-mitigation-and-suppression-techniques#pauli-twirling), [cancelación de error probabilístico](/docs/guides/error-mitigation-and-suppression-techniques#probabilistic-error-cancellation-pec) (PEC) y [extrapolación de ruido cero](/docs/guides/error-mitigation-and-suppression-techniques#zero-noise-extrapolation-zne) (ZNE) (mediante [amplificación de error probabilístico](/docs/guides/error-mitigation-and-suppression-techniques#probabilistic-error-amplification-pea) (PEA)).\n", "\n", "Las puertas fraccionarias requieren un flujo de trabajo diferente en comparación con el enfoque estándar.\n", "Este tutorial explica cómo trabajar con puertas fraccionarias a través de una aplicación práctica.\n", "\n", "Para más información sobre las puertas fraccionarias, consulte lo siguiente.\n", "\n", "* [Puertas fraccionarias](/docs/guides/fractional-gates)\n", "* [Cuándo *no* utilizar puertas fraccionarias](/docs/guides/fractional-gates#when-not-to-use)\n", "\n" ] }, { "cell_type": "markdown", "id": "a4bdab87", "metadata": {}, "source": [ "\n", "\n", "### Enfoques de flujo de trabajo para la restricción del ángulo RZZ\n", "\n" ] }, { "cell_type": "markdown", "id": "db213506", "metadata": {}, "source": [ "El flujo de trabajo para utilizar puertas fraccionarias suele seguir el flujo de trabajo [de patrones de Qiskit](/docs/guides/intro-to-patterns).\n", "La diferencia fundamental es que todos los ángulos RZZ deben cumplir la restricción « $0 < \\theta \\leq \\pi/2$ ».\n", "Existen dos enfoques para garantizar que se cumpla esta condición, tal y como se explica a continuación. Recomendamos el segundo enfoque y, en este tutorial, lo ilustramos mediante un ejemplo inspirado en el método del núcleo cuántico.\n", "Para comprender mejor en qué contextos pueden resultar útiles los núcleos cuánticos, recomendamos leer [el artículo de Liu, Arunachalam y Temme (2021)](https://www.nature.com/articles/s41567-021-01287-z).\n", "\n", "También puedes seguir el tutorial [de formación sobre kernels cuánticos](/docs/tutorials/quantum-kernel-training) y la lección [sobre kernels cuánticos](/learning/courses/quantum-machine-learning/quantum-kernel-methods) del curso de aprendizaje automático cuántico en IBM Quantum® Learning.\n", "\n" ] }, { "cell_type": "markdown", "id": "5797ed7e", "metadata": {}, "source": [ "\n", "\n", "#### 1. Generar valores de parámetros que satisfagan la restricción del ángulo RZZ\n", "\n", "Si está seguro de que todos los ángulos RZZ se encuentran dentro del intervalo válido, puede seguir el flujo de trabajo estándar de los patrones Qiskit.\n", "En este caso, basta con enviar los valores de los parámetros como parte de PUB. El flujo de trabajo es el siguiente.\n", "\n", "```python\n", "pm = generate_preset_pass_manager(backend=backend, ...)\n", "t_circuit = pm.run(circuit)\n", "t_observable = observable.apply_layout(t_circuit.layout)\n", "sampler.run([(t_circuit, parameter_values)])\n", "estimator.run([(t_circuit, t_observable, parameter_values)])\n", "```\n", "\n", "Si intenta enviar un PUB que incluya una puerta RZZ con un ángulo fuera del intervalo válido, aparecerá un mensaje de error como el siguiente:\n", "\n", "```\n", "'The instruction rzz is supported only for angles in the range [0, pi/2], but an angle (20.0) outside of this range has been requested; via parameter value(s) γ[0]=10.0, substituted in parameter expression 2.0*γ[0].'\n", "```\n", "\n", "Para evitar este error, utiliza el segundo método que se describe a continuación.\n", "\n" ] }, { "cell_type": "markdown", "id": "d3e00f37", "metadata": {}, "source": [ "\n", "\n", "#### 2. Asignar valores de parámetros a los circuitos antes de la transpilación\n", "\n", "El `qiskit-ibm-runtime` paquete ofrece una pasada de transpilador especializada denominada [`FoldRzzAngle`](/docs/api/qiskit-ibm-runtime/transpiler-passes-fold-rzz-angle).\n", "Esta pasada transforma los circuitos cuánticos de tal forma que todos los ángulos RZZ cumplan la restricción de ángulo RZZ.\n", "Si proporcionas el backend a `generate_preset_pass_manager` o `transpile`, Qiskit aplica `FoldRzzAngle` automáticamente a los circuitos cuánticos.\n", "Este enfoque requiere que se asignen valores a los parámetros de los circuitos cuánticos antes de la transpilación.\n", "El proceso se desarrolla de la siguiente manera.\n", "\n", "```python\n", "pm = generate_preset_pass_manager(backend=backend, ...)\n", "b_circuit = circuit.assign_parameters(parameter_values)\n", "t_circuit = pm.run(b_circuit)\n", "t_observable = observable.apply_layout(t_circuit.layout)\n", "sampler.run([(t_circuit,)])\n", "estimator.run([(t_circuit, t_observable)])\n", "```\n", "\n", "Cabe señalar que este flujo de trabajo conlleva un mayor coste computacional que el primer enfoque, ya que implica asignar valores a los parámetros de los circuitos cuánticos y almacenar localmente los circuitos con los parámetros definidos.\n", "\n" ] }, { "cell_type": "markdown", "id": "b7cb1bd2", "metadata": {}, "source": [ "\n", " **Tome nota de un problema conocido en `qiskit-ibm-runtime` v0.47.0** donde las puertas RZZ con ángulos no válidos podrían permanecer en los circuitos incluso después de la transpilación en ciertos escenarios.\n", "\n", " Consulta [qiskit-ibm-runtime#2441](https://github.com/Qiskit/qiskit-ibm-runtime/issues/2441) para seguir la evolución de este asunto.\n", " Recomendamos la siguiente solución provisional hasta que se resuelva el problema.\n", "\n", " ```python\n", " pm = generate_preset_pass_manager(backend=backend, ...)\n", " pm.post_optimization = PassManager(\n", " [\n", " FoldRzzAngle(),\n", " Optimize1qGatesDecomposition(target=backend.target),\n", " RemoveIdentityEquivalent(target=backend.target),\n", " ]\n", " )\n", " ... = pm.run(...)\n", " ```\n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "aaa153e7", "metadata": {}, "source": [ "\n", "\n", "## Requisitos\n", "\n", "Antes de empezar este tutorial, asegúrate de tener instalado lo siguiente:\n", "\n", "* Qiskit SDK v2.0 o posterior, con soporte [de visualización](/docs/api/qiskit/visualization)\n", "* Qiskit Runtime v0.41 o posterior (`pip install qiskit-ibm-runtime`)\n", "* Qiskit Aer v0.17 o posterior (`pip install qiskit-aer`)\n", "* Constructor de bases Qiskit (`pip install qiskit_basis_constructor`)\n", "\n" ] }, { "cell_type": "markdown", "id": "5f43ce5d", "metadata": {}, "source": [ "\n", "\n", "## Configuración\n", "\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "a6a15694", "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "from qiskit import QuantumCircuit, generate_preset_pass_manager\n", "from qiskit.circuit import ParameterVector\n", "from qiskit.circuit.library import UGate, n_local, unitary_overlap\n", "from qiskit.transpiler import Target, PassManager\n", "from qiskit.transpiler.passes import (\n", " Optimize1qGatesDecomposition,\n", " RemoveIdentityEquivalent,\n", ")\n", "from qiskit_aer.primitives import SamplerV2 as AerSampler\n", "from qiskit_basis_constructor import DEFAULT_EQUIVALENCE_LIBRARY\n", "from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2\n", "from qiskit_ibm_runtime.transpiler.passes import FoldRzzAngle" ] }, { "cell_type": "markdown", "id": "3e94382d", "metadata": {}, "source": [ "\n", "\n", "### Habilitar puertas fraccionarias y comprobar puertas básicas\n", "\n", "Para utilizar puertas fraccionarias, puede obtener un backend que las admita configurando la opción `use_fractional_gates=True` .\n", "Si el backend soporta puertas fraccionarias, verá `rzz` y `rx` listadas entre sus puertas base.\n", "\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "fd577102", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Backend: ibm_marrakesh\n", "No fractional gates: ['cz', 'id', 'rz', 'sx', 'x']\n", "With fractional gates: ['cz', 'id', 'rx', 'rz', 'rzz', 'sx', 'x']\n" ] } ], "source": [ "service = QiskitRuntimeService()\n", "backend = service.least_busy(\n", " operational=True, simulator=False, min_num_qubits=133\n", ") # backend should be a heron device or later\n", "backend_name = backend.name\n", "backend_c = service.backend(backend_name) # w/o fractional gates\n", "backend_f = service.backend(\n", " backend_name, use_fractional_gates=True\n", ") # w/ fractional gates\n", "print(f\"Backend: {backend_name}\")\n", "print(f\"No fractional gates: {backend_c.basis_gates}\")\n", "print(f\"With fractional gates: {backend_f.basis_gates}\")\n", "if \"rzz\" not in backend_f.basis_gates:\n", " print(f\"Backend {backend_name} does not support fractional gates\")" ] }, { "cell_type": "markdown", "id": "3f11c5a3", "metadata": {}, "source": [ "\n", "\n", "## Ejemplo de simulador a pequeña escala\n", "\n", "En esta sección, repasamos los cuatro pasos del flujo de trabajo [de Qiskit Patterns](/docs/guides/intro-to-patterns) en un simulador, utilizando el circuito del núcleo cuántico como ejemplo práctico.\n", "\n" ] }, { "cell_type": "markdown", "id": "7bfd6a97", "metadata": {}, "source": [ "\n", "\n", "### Paso 1: Asignar entradas clásicas a un problema cuántico\n", "\n", "\n", "\n", "#### Circuito de núcleo cuántico\n", "\n", "En esta sección, exploramos el circuito de núcleo cuántico utilizando puertas RZZ para introducir el flujo de trabajo para puertas fraccionarias.\n", "\n", "Comenzamos construyendo un circuito cuántico para calcular las entradas individuales de la matriz del núcleo.\n", "Para ello, se combinan circuitos de mapas de características ZZ con una superposición unitaria.\n", "La función kernel toma vectores en el espacio mapeado de características y devuelve su producto interno como una entrada de la matriz kernel: $K(x, y) = \\langle \\Phi(x) | \\Phi(y) \\rangle,$ donde $|\\Phi(x)\\rangle$ representa el estado cuántico mapeado.\n", "\n", "Construimos manualmente un circuito de mapa de características ZZ utilizando puertas RZZ.\n", "`zz_feature_map`Aunque Qiskit ofrece una función integrada, actualmente no es compatible con las puertas RZZ, según se indica en Qiskit v2.4.1 ( [véase el problema](https://github.com/Qiskit/qiskit/issues/14469) ).\n", "\n", "A continuación, calculamos la función kernel para entradas idénticas, por ejemplo, $K(x, x) = 1$. En ordenadores cuánticos ruidosos, este valor puede ser inferior a 1 debido al ruido.\n", "Un resultado cercano a 1 indica menor ruido en la ejecución.\n", "En este tutorial, nos referiremos a este valor como la *fidelidad*, definida como $\\text{fidelity} = K(x, x).$\n", "\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "e7d5b52a", "metadata": {}, "outputs": [], "source": [ "optimization_level = 2\n", "shots = 2000\n", "reps = 3\n", "rng = np.random.default_rng(seed=123)" ] }, { "cell_type": "code", "execution_count": 4, "id": "2e9ab33d", "metadata": {}, "outputs": [], "source": [ "def my_zz_feature_map(num_qubits: int, reps: int = 1) -> QuantumCircuit:\n", " x = ParameterVector(\"x\", num_qubits * reps)\n", " qc = QuantumCircuit(num_qubits)\n", " qc.h(range(num_qubits))\n", " for k in range(reps):\n", " K = k * num_qubits\n", " for i in range(num_qubits):\n", " qc.rz(x[i + K], i)\n", " pairs = [(i, i + 1) for i in range(num_qubits - 1)]\n", " for i, j in pairs[0::2] + pairs[1::2]:\n", " qc.rzz((np.pi - x[i + K]) * (np.pi - x[j + K]), i, j)\n", " return qc\n", "\n", "\n", "def quantum_kernel(num_qubits: int, reps: int = 1) -> QuantumCircuit:\n", " qc = my_zz_feature_map(num_qubits, reps=reps)\n", " inner_product = unitary_overlap(qc, qc, \"x\", \"y\", insert_barrier=True)\n", " inner_product.measure_all()\n", " return inner_product\n", "\n", "\n", "def random_parameters(inner_product: QuantumCircuit) -> np.ndarray:\n", " return np.tile(rng.random(inner_product.num_parameters // 2), 2)\n", "\n", "\n", "def fidelity(result) -> float:\n", " ba = result.data.meas\n", " return ba.get_int_counts().get(0, 0) / ba.num_shots" ] }, { "cell_type": "markdown", "id": "f676ff81", "metadata": {}, "source": [ "Se generan circuitos de núcleos cuánticos y sus correspondientes valores de parámetros para sistemas de 4 a 40 qubits, y posteriormente se evalúan sus fidelidades.\n", "\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "24116973", "metadata": {}, "outputs": [], "source": [ "qubits = list(range(4, 12, 2))\n", "circuits = [quantum_kernel(i, reps=reps) for i in qubits]\n", "params = [random_parameters(circ) for circ in circuits]" ] }, { "cell_type": "markdown", "id": "30a7c442", "metadata": {}, "source": [ "El circuito de cuatro qubits se visualiza a continuación.\n", "\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "b3d6341a", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "circuits[0].draw(\"mpl\", fold=-1)" ] }, { "cell_type": "markdown", "id": "07f31cbe", "metadata": {}, "source": [ "En el flujo de trabajo estándar de los patrones Qiskit, los valores de los parámetros suelen pasarse a la primitiva Sampler o Estimator como parte de un PUB.\n", "Sin embargo, cuando se utiliza un backend que admite puertas fraccionarias, estos valores de parámetros deben asignarse explícitamente al circuito cuántico antes de la transpilación.\n", "\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "6c9c1977", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b_qc = [\n", " circ.assign_parameters(param) for circ, param in zip(circuits, params)\n", "]\n", "b_qc[0].draw(\"mpl\", fold=-1)" ] }, { "cell_type": "markdown", "id": "7513072b", "metadata": {}, "source": [ "\n", "\n", "### Paso 2: Optimizar el problema para la ejecución en hardware cuántico\n", "\n" ] }, { "cell_type": "markdown", "id": "804ba317", "metadata": {}, "source": [ "A continuación, transpilamos el circuito utilizando el gestor de pases siguiendo el patrón estándar de Qiskit.\n", "Al proporcionar un backend que admita puertas fraccionarias a `generate_preset_pass_manager`, se incluye automáticamente un pase especializado denominado `FoldRzzAngle` .\n", "Este paso modifica el circuito para cumplir con las restricciones de ángulo RZZ.\n", "Como resultado, las puertas RZZ con valores negativos en la figura anterior se transforman en valores positivos, y se añaden algunas puertas X adicionales.\n", "\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "6054bdea", "metadata": {}, "outputs": [], "source": [ "backend_f = service.backend(name=backend_name, use_fractional_gates=True)\n", "# pm_f includes `FoldRzzAngle` pass\n", "pm_f = generate_preset_pass_manager(\n", " optimization_level=optimization_level, backend=backend_f\n", ")\n", "pm_f.post_optimization = PassManager(\n", " [\n", " FoldRzzAngle(),\n", " Optimize1qGatesDecomposition(target=backend_f.target),\n", " RemoveIdentityEquivalent(target=backend_f.target),\n", " ]\n", ")" ] }, { "cell_type": "code", "execution_count": 9, "id": "a18e5c70", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "OrderedDict({'rz': 35, 'rzz': 18, 'x': 13, 'rx': 9, 'measure': 4, 'barrier': 2})\n" ] }, { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "t_qc_f = pm_f.run(b_qc)\n", "print(t_qc_f[0].count_ops())\n", "t_qc_f[0].draw(\"mpl\", fold=-1)" ] }, { "cell_type": "markdown", "id": "a4cd07d1", "metadata": {}, "source": [ "Para evaluar el impacto de las puertas fraccionarias, evaluamos el número de puertas no locales (CZ y RZZ para este backend), junto con las profundidades y duraciones de los circuitos, y comparamos estas métricas con las de un flujo de trabajo estándar posterior.\n", "\n" ] }, { "cell_type": "code", "execution_count": 10, "id": "b5bcf9ad", "metadata": {}, "outputs": [], "source": [ "nnl_f = [qc.num_nonlocal_gates() for qc in t_qc_f]\n", "depth_f = [qc.depth() for qc in t_qc_f]\n", "duration_f = [\n", " qc.estimate_duration(backend_f.target, unit=\"u\") for qc in t_qc_f\n", "]" ] }, { "cell_type": "markdown", "id": "629406cc", "metadata": {}, "source": [ "\n", "\n", "### Paso 3: Ejecutar utilizando Qiskit primitives\n", "\n" ] }, { "cell_type": "markdown", "id": "87926539", "metadata": {}, "source": [ "Ejecutamos el circuito transpilado con el backend que soporta puertas fraccionarias.\n", "\n" ] }, { "cell_type": "code", "execution_count": 11, "id": "a68acf11", "metadata": {}, "outputs": [], "source": [ "sampler_f = AerSampler.from_backend(backend_f)" ] }, { "cell_type": "code", "execution_count": 12, "id": "a703b939", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "085ce928-767e-4200-93bf-3905e5411cfe\n" ] } ], "source": [ "job = sampler_f.run(t_qc_f, shots=shots)\n", "print(job.job_id())" ] }, { "cell_type": "markdown", "id": "6c9fd10d", "metadata": {}, "source": [ "\n", "\n", "### Paso 4: Procesamiento posterior y devolución del resultado en el formato clásico deseado\n", "\n" ] }, { "cell_type": "markdown", "id": "7a865036", "metadata": {}, "source": [ "Puede obtener el valor de la función kernel $K(x, x)$ midiendo la probabilidad de la cadena de bits completamente nula `00...00` en la salida.\n", "\n" ] }, { "cell_type": "code", "execution_count": 13, "id": "1f0d9c51", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0.929, 0.882, 0.8645, 0.817]\n" ] } ], "source": [ "result = job.result()\n", "fidelity_f = [fidelity(result=res) for res in result]\n", "print(fidelity_f)" ] }, { "cell_type": "markdown", "id": "a5bcd1a8", "metadata": {}, "source": [ "\n", "\n", "### Comparación del flujo de trabajo y el circuito sin puertas fraccionarias\n", "\n", "En esta sección, presentamos el flujo de trabajo estándar de Qiskit Patterns utilizando un backend que no admite puertas fraccionarias.\n", "Al comparar los circuitos transpilados, observarás que la versión que utiliza puertas fraccionarias (de la sección anterior) es más compacta que la que no las utiliza.\n", "\n" ] }, { "cell_type": "code", "execution_count": 14, "id": "e97fd0d5", "metadata": {}, "outputs": [], "source": [ "# step 1: map classical inputs to quantum problem\n", "# `circuits` and `params` from the previous section are reused here" ] }, { "cell_type": "code", "execution_count": 15, "id": "a10f2d95", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "OrderedDict({'rz': 130, 'sx': 80, 'cz': 36, 'measure': 4, 'barrier': 2})\n" ] }, { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# step 2: optimize circuits\n", "backend_c = service.backend(backend_name) # w/o fractional gates\n", "pm_c = generate_preset_pass_manager(\n", " optimization_level=optimization_level, backend=backend_c\n", ")\n", "t_qc_c = pm_c.run(circuits)\n", "print(t_qc_c[0].count_ops())\n", "t_qc_c[0].draw(\"mpl\", fold=-1)" ] }, { "cell_type": "code", "execution_count": 16, "id": "bb3475df", "metadata": {}, "outputs": [], "source": [ "nnl_c = [qc.num_nonlocal_gates() for qc in t_qc_c]\n", "depth_c = [qc.depth() for qc in t_qc_c]\n", "duration_c = [\n", " qc.estimate_duration(backend_c.target, unit=\"u\") for qc in t_qc_c\n", "]" ] }, { "cell_type": "code", "execution_count": 17, "id": "e8d307c0", "metadata": {}, "outputs": [], "source": [ "# step 3: execute\n", "sampler_c = AerSampler.from_backend(backend_c)" ] }, { "cell_type": "code", "execution_count": 18, "id": "983dd26f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "f2cca29d-7263-4976-9e51-13a91b75c3ae\n" ] } ], "source": [ "job = sampler_c.run(pubs=zip(t_qc_c, params), shots=shots)\n", "print(job.job_id())" ] }, { "cell_type": "code", "execution_count": 19, "id": "a6a6fa77", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0.8625, 0.7605, 0.702, 0.671]\n" ] } ], "source": [ "# step 4: post-processing\n", "result = job.result()\n", "fidelity_c = [fidelity(res) for res in result]\n", "print(fidelity_c)" ] }, { "cell_type": "markdown", "id": "765a7980", "metadata": {}, "source": [ "\n", "\n", "### Comparación de la profundidad, la duración y la fidelidad\n", "\n", "En esta sección, comparamos el número de puertas no locales y las fidelidades entre circuitos con y sin puertas fraccionarias.\n", "Esto pone de relieve las posibles ventajas de utilizar puertas fraccionarias en términos de eficacia y calidad de ejecución.\n", "\n" ] }, { "cell_type": "code", "execution_count": 20, "id": "ef343a53", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.plot(qubits, depth_c, \"-o\", label=\"no fractional gates\")\n", "plt.plot(qubits, depth_f, \"-o\", label=\"with fractional gates\")\n", "plt.xlabel(\"number of qubits\")\n", "plt.ylabel(\"depth\")\n", "plt.title(\"Comparison of depths\")\n", "plt.grid()\n", "plt.legend()" ] }, { "cell_type": "code", "execution_count": 21, "id": "98bb2cd0", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.plot(qubits, duration_c, \"-o\", label=\"no fractional gates\")\n", "plt.plot(qubits, duration_f, \"-o\", label=\"with fractional gates\")\n", "plt.xlabel(\"number of qubits\")\n", "plt.ylabel(\"duration (µs)\")\n", "plt.title(\"Comparison of durations\")\n", "plt.grid()\n", "plt.legend()" ] }, { "cell_type": "code", "execution_count": 22, "id": "1383b242", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.plot(qubits, nnl_c, \"-o\", label=\"no fractional gates\")\n", "plt.plot(qubits, nnl_f, \"-o\", label=\"with fractional gates\")\n", "plt.xlabel(\"number of qubits\")\n", "plt.ylabel(\"number of non-local gates\")\n", "plt.title(\"Comparison of numbers of non-local gates\")\n", "plt.grid()\n", "plt.legend()" ] }, { "cell_type": "code", "execution_count": 23, "id": "8b4594f5", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.plot(qubits, fidelity_c, \"-o\", label=\"no fractional gates\")\n", "plt.plot(qubits, fidelity_f, \"-o\", label=\"with fractional gates\")\n", "plt.xlabel(\"number of qubits\")\n", "plt.ylabel(\"fidelity\")\n", "plt.title(\"Comparison of fidelities\")\n", "plt.grid()\n", "plt.legend()" ] }, { "cell_type": "markdown", "id": "9f17acd5", "metadata": {}, "source": [ "\n", "\n", "## Ejemplo de hardware a gran escala\n", "\n", "En esta sección, comparamos el rendimiento del flujo de trabajo del núcleo cuántico, con y sin puertas fraccionarias, en hardware cuántico de hasta 40 qubits.\n", "\n" ] }, { "cell_type": "markdown", "id": "fd68378c", "metadata": {}, "source": [ "\n", "\n", "### Pasos 1 a 4 combinados\n", "\n", "El flujo de trabajo sigue la misma estructura que el ejemplo a pequeña escala. Transpilamos todos los circuitos, tanto los que contienen puertas fraccionarias como los que no, recopilamos métricas y, a continuación, enviamos los circuitos a hardware cuántico real.\n", "\n" ] }, { "cell_type": "code", "execution_count": 24, "id": "4431bf56", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "job id (w/ fractional gates): d8uasitbh0os73eqnpig\n" ] } ], "source": [ "# -------------------------Step 1-------------------------\n", "qubits = list(range(4, 44, 4))\n", "circuits = [quantum_kernel(i, reps=reps) for i in qubits]\n", "params = [random_parameters(circ) for circ in circuits]\n", "b_qc = [\n", " circ.assign_parameters(param) for circ, param in zip(circuits, params)\n", "]\n", "\n", "\n", "def benchmark(b_qc, backend):\n", " # -------------------------Step 2-------------------------\n", " pm = generate_preset_pass_manager(optimization_level, backend=backend)\n", " if \"rzz\" in backend.target.operation_names:\n", " # workaround until https://github.com/Qiskit/qiskit-ibm-runtime/issues/2441 is resolved\n", " pm.post_optimization = PassManager(\n", " [\n", " FoldRzzAngle(),\n", " Optimize1qGatesDecomposition(target=backend.target),\n", " RemoveIdentityEquivalent(target=backend.target),\n", " ]\n", " )\n", " t_qc = pm.run(b_qc)\n", " nnl = [qc.num_nonlocal_gates() for qc in t_qc]\n", " depth = [qc.depth() for qc in t_qc]\n", " duration = [\n", " qc.estimate_duration(backend_f.target, unit=\"u\") for qc in t_qc\n", " ]\n", "\n", " # -------------------------Step 3-------------------------\n", " sampler = SamplerV2(mode=backend)\n", " sampler.options.dynamical_decoupling.enable = True\n", " sampler.options.dynamical_decoupling.sequence_type = \"XY4\"\n", " sampler.options.dynamical_decoupling.skip_reset_qubits = True\n", " sampler.options.environment.job_tags = [\"TUT_FG\"]\n", " job = sampler.run(t_qc, shots=shots)\n", " job_id = job.job_id()\n", " return nnl, depth, duration, job_id\n", "\n", "\n", "def postprocessing(job_id: str):\n", " # -------------------------Step 4-------------------------\n", " job = service.job(job_id)\n", " result = job.result()\n", " fidelities = [fidelity(result=res) for res in result]\n", " usage = job.usage()\n", " return fidelities, usage\n", "\n", "\n", "backend_f = service.backend(backend_name, use_fractional_gates=True)\n", "nnl_f, depth_f, duration_f, job_id_f = benchmark(\n", " b_qc, backend_f\n", ") # step 2 & 3\n", "print(\"job id (w/ fractional gates):\", job_id_f)\n", "fidelity_f, usage_f = postprocessing(job_id_f) # step 4" ] }, { "cell_type": "code", "execution_count": 25, "id": "4a5d15a2", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "job id (w/o fractional gates): d8uav3lposuc738pruug\n" ] } ], "source": [ "backend_c = service.backend(backend_name, use_fractional_gates=False)\n", "nnl_c, depth_c, duration_c, job_id_c = benchmark(b_qc, backend_c)\n", "print(\"job id (w/o fractional gates):\", job_id_c)\n", "fidelity_c, usage_c = postprocessing(job_id_c)" ] }, { "cell_type": "markdown", "id": "9f78441e", "metadata": {}, "source": [ "A continuación, comparamos las métricas.\n", "\n" ] }, { "cell_type": "code", "execution_count": 26, "id": "b409e8d3", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.plot(qubits, depth_c, \"-o\", label=\"no fractional gates\")\n", "plt.plot(qubits, depth_f, \"-o\", label=\"with fractional gates\")\n", "plt.xlabel(\"number of qubits\")\n", "plt.ylabel(\"depth\")\n", "plt.title(\"Comparison of depths\")\n", "plt.grid()\n", "plt.legend()" ] }, { "cell_type": "code", "execution_count": 27, "id": "09f91f0f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.plot(qubits, duration_c, \"-o\", label=\"no fractional gates\")\n", "plt.plot(qubits, duration_f, \"-o\", label=\"with fractional gates\")\n", "plt.xlabel(\"number of qubits\")\n", "plt.ylabel(\"duration (µs)\")\n", "plt.title(\"Comparison of durations\")\n", "plt.grid()\n", "plt.legend()" ] }, { "cell_type": "code", "execution_count": 28, "id": "c9308517", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.plot(qubits, nnl_c, \"-o\", label=\"no fractional gates\")\n", "plt.plot(qubits, nnl_f, \"-o\", label=\"with fractional gates\")\n", "plt.xlabel(\"number of qubits\")\n", "plt.ylabel(\"number of non-local gates\")\n", "plt.title(\"Comparison of numbers of non-local gates\")\n", "plt.grid()\n", "plt.legend()" ] }, { "cell_type": "code", "execution_count": 29, "id": "234731d4", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.plot(qubits, fidelity_c, \"-o\", label=\"no fractional gates\")\n", "plt.plot(qubits, fidelity_f, \"-o\", label=\"with fractional gates\")\n", "plt.xlabel(\"number of qubits\")\n", "plt.ylabel(\"fidelity\")\n", "plt.title(\"Comparison of fidelities\")\n", "plt.grid()\n", "plt.legend()" ] }, { "cell_type": "markdown", "id": "d38b9fe1", "metadata": {}, "source": [ "Comparamos el tiempo de uso de la QPU con y sin puertas fraccionarias. Los resultados de la celda siguiente muestran que los tiempos de uso de la QPU son casi idénticos.\n", "\n" ] }, { "cell_type": "code", "execution_count": 30, "id": "793326ca", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "no fractional gates: 8 seconds\n", "fractional gates: 8 seconds\n" ] } ], "source": [ "print(f\"no fractional gates: {usage_c} seconds\")\n", "print(f\"fractional gates: {usage_f} seconds\")" ] }, { "cell_type": "markdown", "id": "efe18f80", "metadata": {}, "source": [ "\n", "\n", "## Tema avanzado: Uso exclusivo de puertas RX fraccionarias\n", "\n", "La necesidad de modificar el flujo de trabajo cuando se utilizan compuertas fraccionarias se debe principalmente a la restricción de los ángulos de las compuertas RZZ.\n", "Sin embargo, si utilizas sólo las compuertas fraccionarias RX y excluyes las compuertas fraccionarias RZZ, puedes continuar siguiendo el flujo de trabajo estándar de los patrones Qiskit.\n", "Este enfoque todavía puede ofrecer beneficios significativos, en particular en circuitos que implican un gran número de puertas RX y puertas U, reduciendo el número total de puertas y mejorando potencialmente el rendimiento.\n", "En esta sección, demostramos cómo optimizar sus circuitos utilizando sólo puertas RX fraccionarias, omitiendo las puertas RZZ.\n", "\n", "Para ello, proporcionamos una función de utilidad que permite desactivar una puerta base específica en un objeto Target.\n", "Aquí, lo utilizamos para desactivar las puertas RZZ.\n", "\n" ] }, { "cell_type": "code", "execution_count": 31, "id": "ab43ba23", "metadata": {}, "outputs": [], "source": [ "def remove_instruction_from_target(target: Target, gate_name: str) -> Target:\n", " new_target = Target(\n", " description=target.description,\n", " num_qubits=target.num_qubits,\n", " dt=target.dt,\n", " granularity=target.granularity,\n", " min_length=target.min_length,\n", " pulse_alignment=target.pulse_alignment,\n", " acquire_alignment=target.acquire_alignment,\n", " qubit_properties=target.qubit_properties,\n", " concurrent_measurements=target.concurrent_measurements,\n", " )\n", "\n", " for name, qarg_map in target.items():\n", " if name == gate_name:\n", " continue\n", " instruction = target.operation_from_name(name)\n", " if qarg_map == {None: None}:\n", " qarg_map = None\n", " new_target.add_instruction(instruction, qarg_map, name=name)\n", " return new_target" ] }, { "cell_type": "markdown", "id": "7f689a02", "metadata": {}, "source": [ "Utilizaremos como ejemplo un circuito formado por puertas U, CZ y RZZ.\n", "\n" ] }, { "cell_type": "code", "execution_count": 32, "id": "6b812497", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "qc = n_local(3, \"u\", \"cz\", \"linear\", reps=1)\n", "qc.rzz(1.1, 0, 1)\n", "qc.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "fa9dc1c4", "metadata": {}, "source": [ "Primero transpilamos el circuito para un backend que no admite puertas fraccionarias.\n", "\n" ] }, { "cell_type": "code", "execution_count": 33, "id": "9e8e0709", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "OrderedDict({'rz': 23, 'sx': 16, 'cz': 4})\n" ] }, { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "pm_c = generate_preset_pass_manager(\n", " optimization_level=optimization_level, backend=backend_c\n", ")\n", "t_qc = pm_c.run(qc)\n", "print(t_qc.count_ops())\n", "t_qc.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "bd0e24da", "metadata": {}, "source": [ "A continuación, transpilamos el mismo circuito utilizando puertas RX fraccionarias, excluyendo las puertas RZZ.\n", "Esto se traduce en una ligera reducción del número total de compuertas, gracias a la implementación más eficiente de las compuertas RX.\n", "\n" ] }, { "cell_type": "code", "execution_count": 34, "id": "db45feb0", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "OrderedDict({'rz': 22, 'sx': 14, 'cz': 4, 'rx': 1})\n" ] }, { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "backend_f = service.backend(backend_name, use_fractional_gates=True)\n", "target = remove_instruction_from_target(backend_f.target, \"rzz\")\n", "pm_f = generate_preset_pass_manager(\n", " optimization_level=optimization_level,\n", " target=target,\n", ")\n", "t_qc = pm_f.run(qc)\n", "print(t_qc.count_ops())\n", "t_qc.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "15140636", "metadata": {}, "source": [ "\n", "\n", "### Optimizar puertas U con puertas RX fraccionarias\n", "\n", "En esta sección, demostramos cómo optimizar las compuertas U utilizando compuertas RX fraccionarias, basándonos en el mismo circuito introducido en la sección anterior.\n", "\n" ] }, { "cell_type": "markdown", "id": "3f73cbda", "metadata": {}, "source": [ "Transpilamos el circuito utilizando sólo puertas RX fraccionarias, excluyendo las puertas RZZ.\n", "Introduciendo una regla de descomposición personalizada, como se muestra a continuación podemos reducir el número de puertas single-qubit necesarias para implementar una puerta U.\n", "\n", "Esta función se está debatiendo actualmente en esta [incidencia](https://github.com/Qiskit/qiskit/issues/13455) de GitHub.\n", "\n" ] }, { "cell_type": "code", "execution_count": 35, "id": "0f0c6d87", "metadata": {}, "outputs": [], "source": [ "# special decomposition rule for UGate\n", "x = ParameterVector(\"x\", 3)\n", "zxz = QuantumCircuit(1)\n", "zxz.rz(x[2] - np.pi / 2, 0)\n", "zxz.rx(x[0], 0)\n", "zxz.rz(x[1] + np.pi / 2, 0)\n", "DEFAULT_EQUIVALENCE_LIBRARY.add_equivalence(UGate(x[0], x[1], x[2]), zxz)" ] }, { "cell_type": "markdown", "id": "91c824d8", "metadata": {}, "source": [ "A continuación, aplicamos el transpilador utilizando `constructor-beta` la traducción que proporciona el `qiskit-basis-constructor` paquete.\n", "Como resultado, el número total de puertas se reduce en comparación con la transpilación anterior.\n", "\n" ] }, { "cell_type": "code", "execution_count": 36, "id": "b19aae7c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "OrderedDict({'rz': 16, 'rx': 9, 'cz': 4})\n" ] }, { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "pm_f = generate_preset_pass_manager(\n", " optimization_level=optimization_level,\n", " target=target,\n", " translation_method=\"constructor-beta\",\n", ")\n", "t_qc = pm_f.run(qc)\n", "print(t_qc.count_ops())\n", "t_qc.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "23ad4615", "metadata": {}, "source": [ "\n", "\n", "## Próximos pasos\n", "\n", "\n", " Si este trabajo te ha parecido interesante, quizá te interese el siguiente material:\n", "\n", " * Guía [sobre puertas fraccionarias](/docs/guides/fractional-gates)\n", " * [Cuándo *no* utilizar puertas fraccionarias](/docs/guides/fractional-gates#when-not-to-use)\n", " * [`FoldRzzAngle`](/docs/api/qiskit-ibm-runtime/transpiler-passes-fold-rzz-angle) Referencia de la API de la pasada del transpilador\n", " * Tutorial [de formación](/docs/tutorials/quantum-kernel-training) sobre el núcleo de Quantum\n", " * La lección sobre [los núcleos cuánticos](/learning/courses/quantum-machine-learning/quantum-kernel-methods) del curso de aprendizaje automático cuántico\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" }, "hours": 1, "qpuSeconds": 30 }, "nbformat": 4, "nbformat_minor": 5 }