{ "cells": [ { "attachments": {}, "cell_type": "markdown", "id": "7dc25056-2c3c-435a-a827-1930f8bb768f", "metadata": { "gloss": { "ansatz": { "text": "Combination of a reference operator and a variational form, to describe the search space that we're exploring.", "title": "Ansatz" }, "variational": { "text": "Layers of parameterized gates that are repeated a certain number of times, and the parameters of the gates are optimized during the algorithm to minimize the cost function.", "title": "Variational form" } } }, "source": [ "---\n", "title: \"ansatzes y formas variacionales\"\n", "description: \"Esta lección explica qué es un ansatz y en qué se diferencia del estado de referencia. Se dan ejemplos de ansaetze.\"\n", "---\n", "\n", "{/* cspell:ignore ZZII IZZI ZIIZ IZIZ IIZZ ansä */}\n", "\n", "\n", "\n", "# Ansaetze y formas variacionales\n", "\n", "En el corazón de todos los algoritmos variacionales se encuentra la idea clave de analizar las diferencias entre estados, que están convenientemente relacionados a través de algún mapeo bien comportado (por ejemplo, continuo, diferenciable) de un conjunto de parámetros o variables - de ahí el nombre.\n", "\n", "En primer lugar, exploraremos cómo construir circuitos parametrizados a mano. Utilizaremos estos circuitos para definir un forma variacional que representa una colección de estados parametrizados para que nuestro algoritmo variacional los explore. A continuación, construiremos nuestro ansatz aplicando esta forma variacional a nuestro estado de referencia.\n", "\n", "También estudiaremos cómo compensar velocidad y precisión al explorar este espacio de búsqueda.\n", "\n", "![Un diagrama que muestra los componentes clave de la discusión del ansatz, incluidos los ansaetze heurísticos y los ansaetze específicos del problema.](https://quantum.cloud.ibm.com/learning/images/courses/variational-algorithm-design/ansaetze-and-variational-forms/ansatz-workflow.svg)\n", "\n" ] }, { "attachments": {}, "cell_type": "markdown", "id": "5ebac8e8-6451-46e5-8a01-099f84296a17", "metadata": {}, "source": [ "\n", "\n", "## Circuitos cuánticos parametrizados\n", "\n", "Los algoritmos variacionales operan explorando y comparando una gama de estados cuánticos $|\\psi(\\vec{\\theta})\\rangle$, que dependen de un conjunto finito de parámetros $k$ $\\vec{\\theta} = (\\theta^0, \\ldots, \\theta^{k-1})$. Estos estados pueden prepararse utilizando un circuito cuántico parametrizado, en el que las puertas se definen con parámetros sintonizables. Es posible crear este circuito parametrizado sin vincular ángulos específicos todavía:\n", "\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "4c564fab-ed65-4949-b27f-658b0f1ed621", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.circuit import QuantumCircuit, Parameter\n", "\n", "theta = Parameter(\"θ\")\n", "\n", "qc = QuantumCircuit(3)\n", "qc.rx(theta, 0)\n", "qc.cx(0, 1)\n", "qc.x(2)\n", "\n", "qc.draw(\"mpl\")" ] }, { "cell_type": "code", "execution_count": 2, "id": "4096d161-2916-472b-8abc-d4a6b78955cf", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from math import pi\n", "\n", "angle_list = [pi / 3, pi / 2]\n", "circuits = [qc.assign_parameters({theta: angle}) for angle in angle_list]\n", "\n", "for circuit in circuits:\n", " display(circuit.draw(\"mpl\"))" ] }, { "attachments": {}, "cell_type": "markdown", "id": "f01221c4-f7ee-496a-a664-4b3abc0748c2", "metadata": {}, "source": [ "\n", "\n", "## Forma variacional y Ansatz\n", "\n", "Para optimizar iterativamente desde un estado de referencia $|\\rho\\rangle$ a un estado objetivo $|\\psi(\\vec\\theta)\\rangle$, necesitamos definir una forma variacional $U_V(\\vec{\\theta})$ que representa una colección de estados parametrizados para que nuestro algoritmo variacional los explore:\n", "\n", "$$\n", "\\begin{aligned}\n", "|0\\rangle \\xrightarrow{U_R} U_R|0\\rangle\n", "\n", "& = |\\rho\\rangle \\xrightarrow{U_V(\\vec{\\theta})} U_A(\\vec{\\theta})|0\\rangle \\\\[1mm]\n", "\n", "& = U_V(\\vec{\\theta})U_R|0\\rangle \\\\[1mm]\n", "\n", "& = U_V(\\vec{\\theta})|\\rho\\rangle \\\\[1mm]\n", "\n", "& = |\\psi(\\vec{\\theta})\\rangle \\\\[1mm]\n", "\n", "\\end{aligned}\n", "$$\n", "\n", "Nótese que el estado parametrizado depende tanto del estado de referencia $|\\rho\\rangle$, que no depende de ningún parámetro, como de la forma variacional $U_V(\\vec{\\theta})$, que siempre depende de parámetros. Denominamos ansatz a la combinación de estas dos mitades: $U_A(\\vec\\theta) := U_V(\\vec\\theta)U_R$.\n", "\n", "A medida que construimos nuestro ansatz para representar una colección de estados parametrizados para que los explore nuestro algoritmo variacional, nos damos cuenta de un problema importante: la dimensionalidad. Un sistema $n$ -qubit (es decir, un espacio de Hilbert) tiene un gran número de estados cuánticos distintos en el espacio de configuración. Necesitaríamos un número ingente de parámetros para explorarla a fondo. Cuantitativamente, su dimensionalidad es $D = 2^{2n}$. Para empeorar las cosas, la complejidad del tiempo de ejecución de los algoritmos de búsqueda, y de otros por igual, crece exponencialmente con esta dimensionalidad, un fenómeno al que a menudo se hace referencia en la literatura como la maldición de la dimensionalidad.\n", "\n", "Para contrarrestar este contratiempo, es práctica común imponer algunas restricciones razonables a la forma variacional, de modo que sólo se exploren los estados más relevantes. Encontrar un ansatz truncado eficiente es un área activa de investigación, pero cubriremos dos diseños comunes.\n", "\n" ] }, { "attachments": {}, "cell_type": "markdown", "id": "6d6caf9e-4eb0-4ae1-b9be-6fcfacd23b39", "metadata": {}, "source": [ "\n", "\n", "## Enfoques heurísticos y compensaciones\n", "\n", "Si no dispone de ninguna información sobre su problema concreto que pueda ayudarle a restringir la dimensionalidad, puede probar con una familia arbitraria de circuitos parametrizados con menos de $2^{2n}$ parámetros. Sin embargo, hay que tener en cuenta algunas contrapartidas:\n", "\n", "* **Velocidad** : al reducir el espacio de búsqueda, el algoritmo puede funcionar más rápido.\n", "* **Precisión** : Si se reduce el espacio, se corre el riesgo de excluir la solución real del problema, lo que daría lugar a soluciones subóptimas.\n", "* **Ruido** : Los circuitos más profundos se ven afectados por el ruido, por lo que debemos experimentar con la conectividad, las puertas y la fidelidad de las puertas de nuestro ansatz.\n", "\n", "Existe un equilibrio fundamental entre calidad (o incluso solvencia) y velocidad: cuantos más parámetros, más probabilidades de encontrar un resultado preciso, pero más tiempo se tardará en ejecutar el algoritmo.\n", "\n" ] }, { "attachments": {}, "cell_type": "markdown", "id": "136b5311-f52b-47a0-a7d2-3f1255b0270e", "metadata": {}, "source": [ "\n", "\n", "### Circuitos N-locales\n", "\n", "Uno de los ejemplos más utilizados de ansaetze heurísticos son los [circuitos N-locales](/docs/api/qiskit/qiskit.circuit.library.NLocal), por varias razones:\n", "\n", "* **Implementación eficiente** : El ansatz N-local se compone normalmente de puertas locales sencillas que pueden implementarse eficientemente en un ordenador cuántico, utilizando un pequeño número de qubits físicos. Esto facilita la construcción y optimización de circuitos cuánticos.\n", "* **Captura correlaciones importantes** : El ansatz N-local puede capturar correlaciones importantes entre los qubits de un sistema cuántico, incluso con un número reducido de puertas. Esto se debe a que las puertas locales pueden actuar sobre qubits vecinos y crear entrelazamiento entre ellos, lo que puede ser importante para simular sistemas cuánticos complejos.\n", "\n", "Estos circuitos constan de capas de rotación y de entrelazamiento que se repiten alternativamente una o varias veces de la siguiente manera:\n", "\n", "* Cada capa está formada por puertas de tamaño máximo $N$, donde $N$ tiene que ser menor que el número de qubits.\n", "* Para una capa de rotación, las puertas se apilan unas sobre otras. Podemos utilizar operaciones de rotación estándar, como [`RX`](/docs/api/qiskit/qiskit.circuit.library.RXGate) o [`CRZ`](/docs/api/qiskit/qiskit.circuit.library.CRZGate).\n", "* Para una capa de enredo, podemos utilizar puertas como [`Toffoli` gates](/docs/api/qiskit/qiskit.circuit.library.CCXGate) o [`CX`](/docs/api/qiskit/qiskit.circuit.library.CXGate) con una estrategia de enredo.\n", "* Ambos tipos de capas pueden estar parametrizadas o no, pero al menos una de ellas debe contener parámetros. De lo contrario, sin al menos un parámetro, ¡no habría variaciones!\n", "* Opcionalmente, se añade una capa de rotación adicional al final del circuito.\n", "\n", "Por ejemplo, creemos un circuito de cinco qubits [`NLocal`](/docs/api/qiskit/qiskit.circuit.library.NLocal) con bloques de rotación formados por [`RX`](/docs/api/qiskit/qiskit.circuit.library.RXGate) y [`CRZ`](/docs/api/qiskit/qiskit.circuit.library.CRZGate) compuertas, bloques de entrelazamiento formados por [`Toffoli` compuertas](/docs/api/qiskit/qiskit.circuit.library.CCXGate) que actúan sobre los qubits $[0,1,2]$, $[0,2,3]$, $[4,2,1]$ y $[3,1,0]$ y $2$ repeticiones de cada capa.\n", "\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "c28d7b53-fbd7-42f5-a619-5a6b0b44e9fc", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.circuit.library import NLocal, CCXGate, CRZGate, RXGate\n", "from qiskit.circuit import Parameter\n", "\n", "theta = Parameter(\"θ\")\n", "ansatz = NLocal(\n", " num_qubits=5,\n", " rotation_blocks=[RXGate(theta), CRZGate(theta)],\n", " entanglement_blocks=CCXGate(),\n", " entanglement=[[0, 1, 2], [0, 2, 3], [4, 2, 1], [3, 1, 0]],\n", " reps=2,\n", " insert_barriers=True,\n", ")\n", "ansatz.decompose().draw(\"mpl\")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "d293b8cc-1512-4a65-a3f7-94a979d1736b", "metadata": {}, "source": [ "En el ejemplo anterior, la puerta más grande es la puerta Toffoli, que actúa sobre tres qubits, lo que hace que el circuito sea $3$ -local. Los tipos de circuitos $N$ -locales más utilizados son los circuitos [$2$ -locales con puertas de rotación de un solo qubit y puertas de entrelazamiento](/docs/api/qiskit/qiskit.circuit.library.TwoLocal) $2$ -qubit.\n", "\n", "Vamos a crear un circuito $2$ -local usando la clase [`TwoLocal`](/docs/api/qiskit/qiskit.circuit.library.TwoLocal) de Qiskit. La sintaxis es la misma que en `NLocal`, pero hay algunas diferencias. Por ejemplo, la mayoría de las puertas, como `RX`, `RZ`, y `CNOT`, se pueden pasar como cadenas sin importar las puertas ni crear una instancia de `Parameter` .\n", "\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "c48521ee-db12-449e-af9f-7d8ec0fa7890", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.circuit.library import TwoLocal\n", "\n", "ansatz = TwoLocal(\n", " num_qubits=5,\n", " rotation_blocks=[\"rx\", \"rz\"],\n", " entanglement_blocks=\"cx\",\n", " entanglement=\"linear\",\n", " reps=2,\n", " insert_barriers=True,\n", ")\n", "ansatz.decompose().draw(\"mpl\")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "a6e80571-9bb4-4e33-9581-2c48cad1a566", "metadata": {}, "source": [ "En este caso, utilizamos la distribución de enredo lineal, en la que cada qubit está enredado con el siguiente. Para conocer otras estrategias, consulte la [documentación de `TwoLocal` ](/docs/api/qiskit/qiskit.circuit.library.TwoLocal).\n", "\n" ] }, { "attachments": {}, "cell_type": "markdown", "id": "65d39e58-e54b-4ea3-95bf-ee68d9b89832", "metadata": {}, "source": [ "\n", "\n", "### SU2 eficiente\n", "\n", "[`efficient_su2`](/docs/api/qiskit/qiskit.circuit.library.EfficientSU2) es un circuito eficiente desde el punto de vista del hardware que consta de capas de operaciones de un solo qubit que abarcan SU(2) y `CX` enredos. Se trata de un patrón heurístico que puede utilizarse para preparar funciones de onda de prueba para algoritmos cuánticos variacionales o como circuito de clasificación para el aprendizaje automático.\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "5abc6f15-d7f5-466a-9659-78a11a2c5270", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.circuit.library import efficient_su2\n", "\n", "ansatz = efficient_su2(4, su2_gates=[\"rx\", \"y\"], entanglement=\"linear\", reps=1)\n", "ansatz.decompose().draw(\"mpl\")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "14d01a25-2e2a-47e5-9c50-910599c59502", "metadata": {}, "source": [ "\n", "\n", "## Enfoques específicos para cada problema\n", "\n", "Mientras que las ansaetze heurísticas y de hardware eficiente nos ayudan a resolver un problema de forma ingenua, podemos utilizar el conocimiento específico del problema para restringir nuestro espacio de búsqueda de circuitos a un tipo específico. Esto nos ayudará a ganar velocidad sin perder precisión en nuestro proceso de búsqueda.\n", "\n" ] }, { "attachments": {}, "cell_type": "markdown", "id": "ae376a5f-004c-44af-a6ba-4e4419e350c3", "metadata": {}, "source": [ "\n", "\n", "### Optimización\n", "\n", "En un problema de corte máximo, queremos dividir los nodos de un grafo de forma que se maximice el número de aristas entre nodos de distintos grupos. La partición de corte máximo deseada para el grafo siguiente es clara: el nodo 0 de la izquierda debe estar separado del resto de los nodos de la derecha por un corte.\n", "\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "ef9a5e1d-f70a-4f59-9112-2d8f71b253ba", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import rustworkx as rx\n", "from rustworkx.visualization import mpl_draw\n", "\n", "n = 4\n", "G = rx.PyGraph()\n", "G.add_nodes_from(range(n))\n", "# The edge syntax is (start, end, weight)\n", "edges = [(0, 1, 1.0), (0, 2, 1.0), (0, 3, 1.0), (1, 2, 1.0), (2, 3, 1.0)]\n", "G.add_edges_from(edges)\n", "\n", "mpl_draw(\n", " G, pos=rx.shell_layout(G), with_labels=True, edge_labels=str, node_color=\"#1192E8\"\n", ")" ] }, { "cell_type": "markdown", "id": "65d72527-77b1-4eb4-93e5-762a5f55b838", "metadata": {}, "source": [ "Para utilizar el algoritmo QAOA en un problema de corte máximo, necesitamos un Hamiltoniano de Pauli que codifique el coste de forma que el valor mínimo de la expectativa del operador corresponda al número máximo de aristas entre los nodos de dos grupos diferentes.\n", "\n", "Para este sencillo ejemplo, el operador es una combinación lineal de términos con operadores Z en nodos conectados por una arista (recuérdese que el qubit 0 está más a la derecha): $ZZII + IZZI + ZIIZ + IZIZ + IIZZ$. Una vez construido el operador, el ansatz para el algoritmo QAOA se puede construir fácilmente utilizando el circuito `QAOAAnsatz` de la biblioteca de circuitos Qiskit.\n", "\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "69599589-689e-4e0f-8135-937aedd9430d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Pre-defined ansatz circuit, operator class and visualization tools\n", "from qiskit.circuit.library import QAOAAnsatz\n", "from qiskit.quantum_info import SparsePauliOp\n", "\n", "# Problem to Hamiltonian operator\n", "hamiltonian = SparsePauliOp.from_list(\n", " [(\"ZZII\", 1), (\"IZZI\", 1), (\"ZIIZ\", 1), (\"IZIZ\", 1), (\"IIZZ\", 1)]\n", ")\n", "# QAOA ansatz circuit\n", "ansatz = QAOAAnsatz(hamiltonian, reps=2)\n", "# Draw\n", "ansatz.decompose(reps=3).draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "23728bd9-ac92-4e3a-a886-2238fc5287ad", "metadata": {}, "source": [ "La imagen anterior ilustra el ansatz en puertas básicas para mayor claridad. Sin embargo, puede expresarse en varios niveles de descomposición cambiando el argumento `reps` o dibujando el circuito sin el método de descomposición. Por ejemplo, la siguiente representación muestra directamente la estructura QAOA con el valor de repetición por defecto, que es `reps=1`.\n", "\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "9724a36b-aae6-4d98-aad2-1090f0e1a941", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ansatz.decompose(reps=2).draw(\"mpl\")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "6a8aa7fc-3f80-46b2-b520-b6006d75a404", "metadata": {}, "source": [ "\n", "\n", "### Quantum Machine Learning\n", "\n", "En el aprendizaje automático, una aplicación común es la clasificación de datos en dos o más categorías. Esto implica codificar un punto de datos en un mapa de características que mapea vectores de características clásicas en el espacio cuántico de Hilbert. La construcción de mapas cuánticos de características basados en circuitos cuánticos parametrizados que son difíciles de simular clásicamente es un paso importante para obtener una ventaja potencial sobre los enfoques clásicos de aprendizaje automático y es un área activa de investigación actual.\n", "\n", "En `zz_feature_map` se puede crear un circuito parametrizado. Podemos pasar nuestros puntos de datos al mapa de características ( $x$ ) y una forma variacional separada para pasar pesos como parámetros ( $\\theta$ ).\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "9d3a813b-40cf-4399-b912-714893987c30", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.circuit.library import zz_feature_map, TwoLocal\n", "\n", "data = [0.1, 0.2]\n", "\n", "zz_feature_map_reference = zz_feature_map(feature_dimension=2, reps=2)\n", "zz_feature_map_reference = zz_feature_map_reference.assign_parameters(data)\n", "\n", "variation_form = TwoLocal(2, [\"ry\", \"rz\"], \"cz\", reps=2)\n", "vqc_ansatz = zz_feature_map_reference.compose(variation_form)\n", "vqc_ansatz.decompose().draw(\"mpl\")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "4a1b37bd-8de9-479b-8453-1d8942492731", "metadata": {}, "source": [ "\n", "\n", "## Resumen\n", "\n", "Con esta lección, has aprendido a definir tu espacio de búsqueda con una forma variacional:\n", "\n", "* Preparar estados con un circuito cuántico *parametrizado*, en el que las puertas se definen con parámetros sintonizables\n", "* Cómo construir análisis que compensen velocidad y precisión\n", "* Soluciones heurísticas\n", "* Respuestas a problemas específicos\n", "\n", "Nuestra carga de trabajo variacional de alto nivel tiene el siguiente aspecto:\n", "\n", "![Un diagrama de circuito que muestra dos unitarios: uno que prepara el estado de referencia y otro que prepara el ansatz.](https://quantum.cloud.ibm.com/learning/images/courses/variational-algorithm-design/ansaetze-and-variational-forms/ansatz-circuit.svg)\n", "\n", "Para cada parámetro variacional $\\vec\\theta$, se producirá un estado cuántico diferente. Para encontrar los parámetros óptimos, necesitamos definir una *función de coste* específica del problema para actualizar iterativamente los parámetros de nuestro ansatz.\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": 2 }