{ "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 e formas variacionais\"\n", "description: \"Esta lição explica o que é um ansatz e como ele difere do estado de referência. São apresentados exemplos de ansaetze.\"\n", "---\n", "\n", "{/* cspell:ignore ZZII IZZI ZIIZ IZIZ IIZZ ansä */}\n", "\n", "\n", "\n", "# Ansaetze e formas variacionais\n", "\n", "No centro de todos os algoritmos variacionais está a ideia principal de analisar as diferenças entre os estados, que são convenientemente relacionados por meio de algum mapeamento bem comportado (por exemplo, contínuo, diferenciável) de um conjunto de parâmetros ou variáveis - daí o nome.\n", "\n", "Primeiro, exploraremos como construir circuitos parametrizados manualmente. Usaremos esses circuitos para definir um forma variacional que representa uma coleção de estados parametrizados para o nosso algoritmo variacional explorar. Em seguida, construiremos nosso site ansatz aplicando essa forma variacional ao nosso estado de referência.\n", "\n", "Também exploraremos como negociar velocidade versus precisão ao explorar esse espaço de pesquisa.\n", "\n", "![Um diagrama que mostra os principais componentes da discussão de ansatz, incluindo ansaetze heurística e ansaetze específica do 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 quânticos parametrizados\n", "\n", "Os algoritmos variacionais operam explorando e comparando uma gama de estados quânticos $|\\psi(\\vec{\\theta})\\rangle$, que dependem de um conjunto finito de parâmetros $k$ $\\vec{\\theta} = (\\theta^0, \\ldots, \\theta^{k-1})$. Esses estados podem ser preparados usando um circuito quântico parametrizado, em que as portas são definidas com parâmetros ajustáveis. É possível criar esse circuito parametrizado sem vincular ângulos específicos ainda:\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 e Ansatz\n", "\n", "Para otimizar iterativamente a partir de um estado de referência $|\\rho\\rangle$ para um estado-alvo $|\\psi(\\vec\\theta)\\rangle$, precisamos definir uma forma variacional $U_V(\\vec{\\theta})$ que represente um conjunto de estados parametrizados para o nosso algoritmo variacional explorar:\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", "Observe que o estado parametrizado depende tanto do estado de referência $|\\rho\\rangle$, que não depende de nenhum parâmetro, quanto da forma variacional $U_V(\\vec{\\theta})$, que sempre depende de parâmetros. Referimo-nos à combinação dessas duas metades como um ansatz: $U_A(\\vec\\theta) := U_V(\\vec\\theta)U_R$.\n", "\n", "À medida que construímos nosso ansatz para representar uma coleção de estados parametrizados para o nosso algoritmo variacional explorar, percebemos uma questão importante: a dimensionalidade. Um sistema de $n$ -qubit (ou seja, espaço de Hilbert) tem um grande número de estados quânticos distintos no espaço de configuração. Seria necessário um número excessivo de parâmetros para explorá-lo completamente. Quantitativamente, sua dimensionalidade é $D = 2^{2n}$. Para piorar a situação, a complexidade do tempo de execução dos algoritmos de busca, e de outros semelhantes, cresce exponencialmente com essa dimensionalidade, um fenômeno muitas vezes mencionado na literatura como a maldição da dimensionalidade.\n", "\n", "Para evitar esse contratempo, é prática comum impor algumas restrições razoáveis à forma variacional, de modo que apenas os estados mais relevantes sejam explorados. Encontrar um ansatz truncado eficiente é uma área de pesquisa ativa, mas abordaremos dois projetos comuns.\n", "\n" ] }, { "attachments": {}, "cell_type": "markdown", "id": "6d6caf9e-4eb0-4ae1-b9be-6fcfacd23b39", "metadata": {}, "source": [ "\n", "\n", "## Abordagens heurísticas e compromissos\n", "\n", "Se não tiver nenhuma informação sobre seu problema específico que possa ajudar a restringir a dimensionalidade, você pode tentar uma família arbitrária de circuitos parametrizados com menos de $2^{2n}$ parâmetros. No entanto, há algumas compensações a serem consideradas:\n", "\n", "* **Velocidade** : ao reduzir o espaço de pesquisa, o algoritmo pode ser executado mais rapidamente.\n", "* **Precisão** : Reduzir o espaço pode levar ao risco de excluir a solução real do problema, resultando em soluções abaixo do ideal.\n", "* **Ruído** : Circuitos mais profundos são afetados pelo ruído, portanto, precisamos fazer experiências com a conectividade, as portas e a fidelidade das portas do nosso ansatz.\n", "\n", "Há um compromisso fundamental entre qualidade (ou mesmo capacidade de resolução) e velocidade: quanto mais parâmetros, maior a probabilidade de encontrar um resultado preciso, mas mais tempo levará para executar o algoritmo.\n", "\n" ] }, { "attachments": {}, "cell_type": "markdown", "id": "136b5311-f52b-47a0-a7d2-3f1255b0270e", "metadata": {}, "source": [ "\n", "\n", "### Circuitos locais N\n", "\n", "Um dos exemplos mais usados de respostas heurísticas são os [circuitos N-locais](/docs/api/qiskit/qiskit.circuit.library.NLocal), por alguns motivos:\n", "\n", "* **Implementação eficiente** : O ansatz N-local é normalmente composto de portas locais simples que podem ser implementadas com eficiência em um computador quântico, usando um pequeno número de qubits físicos. Isso facilita a construção e a otimização de circuitos quânticos.\n", "* **Captura correlações importantes** : O ansatz N-local pode capturar correlações importantes entre os qubits em um sistema quântico, mesmo com um pequeno número de portas. Isso ocorre porque as portas locais podem atuar em qubits vizinhos e criar emaranhamento entre eles, o que pode ser importante para a simulação de sistemas quânticos complexos.\n", "\n", "Esses circuitos consistem em camadas de rotação e emaranhamento que são repetidas alternativamente uma ou mais vezes da seguinte forma:\n", "\n", "* Cada camada é formada por portas de tamanho máximo $N$, em que $N$ deve ser menor que o número de qubits.\n", "* Em uma camada de rotação, as portas são empilhadas umas sobre as outras. Podemos usar operações de rotação padrão, como [`RX`](/docs/api/qiskit/qiskit.circuit.library.RXGate) ou [`CRZ`](/docs/api/qiskit/qiskit.circuit.library.CRZGate).\n", "* Para uma camada de emaranhamento, podemos usar portas como [`Toffoli` g](/docs/api/qiskit/qiskit.circuit.library.CCXGate) ates ou [`CX`](/docs/api/qiskit/qiskit.circuit.library.CXGate) com uma estratégia de emaranhamento.\n", "* Os dois tipos de camadas podem ser parametrizados ou não, mas pelo menos um deles precisa conter parâmetros. Caso contrário, sem pelo menos um parâmetro, não haveria variações!\n", "* Opcionalmente, uma camada de rotação extra é adicionada à extremidade do circuito.\n", "\n", "Por exemplo, vamos criar um circuito de cinco qubits [`NLocal`](/docs/api/qiskit/qiskit.circuit.library.NLocal) com blocos de rotação formados por [`RX`](/docs/api/qiskit/qiskit.circuit.library.RXGate) e [`CRZ`](/docs/api/qiskit/qiskit.circuit.library.CRZGate) blocos de emaranhamento formados por [portas `Toffoli` ](/docs/api/qiskit/qiskit.circuit.library.CCXGate) que atuam nos qubits $[0,1,2]$, $[0,2,3]$, $[4,2,1]$ e $[3,1,0]$ e $2$ repetições de cada camada.\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": [ "No exemplo acima, a maior porta é a porta Toffoli, que atua em três qubits, tornando o circuito $3$ -local. O tipo mais comumente usado de circuitos $N$ -local são os circuitos [$2$ -local com portas de rotação de um único qubit e portas de emaranhamento de](/docs/api/qiskit/qiskit.circuit.library.TwoLocal) $2$ -qubit.\n", "\n", "Vamos criar um circuito $2$ -local usando a classe [`TwoLocal`](/docs/api/qiskit/qiskit.circuit.library.TwoLocal) do Qiskit. A sintaxe é a mesma de `NLocal`, mas há algumas diferenças. Por exemplo, a maioria das portas, como `RX`, `RZ` e `CNOT`, pode ser passada como cadeias de caracteres sem importar as portas ou criar uma instância 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": [ "Nesse caso, usamos a distribuição de emaranhamento linear, em que cada qubit é emaranhado com o próximo. Para saber mais sobre outras estratégias, consulte a [documentação do site `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) é um circuito eficiente em termos de hardware que consiste em camadas de operações de um único qubit abrangendo SU(2) e `CX` entanglements. Esse é um padrão heurístico que pode ser usado para preparar funções de onda de teste para algoritmos quânticos variacionais ou como um circuito de classificação para aprendizado de máquina.\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", "## Abordagens específicas para cada problema\n", "\n", "Embora as respostas heurísticas e eficientes de hardware nos ajudem a resolver um problema de forma ingênua, podemos usar o conhecimento específico do problema para restringir nosso espaço de pesquisa de circuitos a um tipo específico. Isso nos ajudará a ganhar velocidade sem perder a precisão em nosso processo de pesquisa.\n", "\n" ] }, { "attachments": {}, "cell_type": "markdown", "id": "ae376a5f-004c-44af-a6ba-4e4419e350c3", "metadata": {}, "source": [ "\n", "\n", "### Otimização\n", "\n", "Em um problema de corte máximo, queremos particionar os nós de um gráfico de forma a maximizar o número de arestas entre os nós em grupos diferentes. A partição de corte máximo desejada para o gráfico abaixo é clara: o 0º nó à esquerda deve ser separado do restante dos nós à direita por um 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 o algoritmo QAOA em um problema de corte máximo, precisamos de um Hamiltoniano de Pauli que codifique o custo de forma que o valor de expectativa mínima do operador corresponda ao número máximo de bordas entre os nós em dois grupos diferentes.\n", "\n", "Para este exemplo simples, o operador é uma combinação linear de termos com operadores Z em nós conectados por uma borda (lembre-se de que o 0º qubit é o mais à direita): $ZZII + IZZI + ZIIZ + IZIZ + IIZZ$. Depois que o operador é construído, o ansatz para o algoritmo QAOA pode ser facilmente construído usando o circuito `QAOAAnsatz` da 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": [ "A imagem anterior ilustra o ansatz em portas básicas para maior clareza. No entanto, ele pode ser expresso em vários níveis de decomposição alterando o argumento `reps` ou desenhando o circuito sem o método de decomposição. Por exemplo, a representação a seguir mostra diretamente a estrutura QAOA com o valor padrão de representantes, que é `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", "No aprendizado de máquina, um aplicativo comum é a classificação de dados em duas ou mais categorias. Isso envolve a codificação de um ponto de dados em um mapa de recursos que mapeia vetores de recursos clássicos no espaço de Hilbert quântico. A construção de mapas de recursos quânticos com base em circuitos quânticos parametrizados que são difíceis de simular classicamente é uma etapa importante para obter uma possível vantagem sobre as abordagens clássicas de aprendizado de máquina e é uma área ativa da pesquisa atual.\n", "\n", "O site `zz_feature_map` pode ser usado para criar um circuito parametrizado. Podemos passar nossos pontos de dados para o mapa de recursos ( $x$ ) e uma forma variacional separada para passar os 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", "## Resumo\n", "\n", "Com esta lição, você aprendeu a definir seu espaço de pesquisa com uma forma variacional:\n", "\n", "* Preparar estados com um circuito quântico *parametrizado*, em que as portas são definidas com parâmetros ajustáveis\n", "* Como criar respostas que compensem a velocidade e a precisão\n", "* Respostas heurísticas\n", "* Respostas específicas para problemas\n", "\n", "Nossa carga de trabalho variacional de alto nível é a seguinte:\n", "\n", "![Um diagrama de circuito mostrando dois unitários: um que prepara o estado de referência e outro que prepara o 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$, será produzido um estado quântico diferente. Para encontrar os parâmetros ideais, precisamos definir uma *função de custo* específica do problema para atualizar iterativamente os parâmetros do nosso 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 }