{ "cells": [ { "cell_type": "markdown", "id": "24576595", "metadata": {}, "source": [ "---\n", "title: \"Núcleos quânticos com portas fracionárias\"\n", "description: \"Utilize portas fracionárias — portas parametrizadas que executam diretamente rotações de ângulos arbitrários — para reduzir a profundidade e a duração dos circuitos de kernel quântico.\"\n", "---\n", "\n", "\n", "\n", "# Núcleos quânticos com portas fracionárias\n", "\n", "*Estimativa de uso: menos de 30 segundos em um processador Heron r2 (OBSERVAÇÃO: esta é apenas uma estimativa. Seu tempo de execução pode variar)*\n", "\n" ] }, { "cell_type": "markdown", "id": "983da41e", "metadata": {}, "source": [ "\n", "\n", "## Resultados do aprendizado\n", "\n", "Ao concluir este tutorial, você deverá compreender:\n", "\n", "* O que são portas fracionárias e como elas reduzem a profundidade e a duração dos circuitos em QPUs d IBM®\n", "* As restrições associadas ao uso de portas fracionárias (em particular, a faixa de ângulos RZZ)\n", "* Como construir um fluxo de trabalho de kernel quântico que utilize portas fracionárias com o Qiskit Runtime\n", "* Como comparar métricas de execução em hardware (profundidade, duração, contagem de portas não locais, fidelidade) com e sem portas fracionárias\n", "* Como usar apenas portas RX fracionárias, mantendo o fluxo de trabalho padrão do Qiskit\n", "\n", "\n", "\n", "## Pré-requisitos\n", "\n", "Sugerimos que você esteja familiarizado com os seguintes tópicos antes de seguir com este tutorial:\n", "\n", "* O fluxo de trabalho [de padrões](/docs/guides/intro-to-patterns) do Qiskit\n", "* Guia sobre [portas fracionárias](/docs/guides/fractional-gates)\n", "* O tutorial [de treinamento de kernels quânticos](/docs/tutorials/quantum-kernel-training) e a aula sobre [kernels quânticos](/learning/courses/quantum-machine-learning/quantum-kernel-methods) do curso de aprendizado de máquina quântico\n", "\n" ] }, { "cell_type": "markdown", "id": "155eab76", "metadata": {}, "source": [ "\n", "\n", "## Segundo plano\n", "\n", "\n", "\n", "### Portas fracionárias em QPUs d IBM\n", "\n", "Portas fracionárias são portas quânticas parametrizadas que permitem a execução direta de rotações de ângulos arbitrários (dentro de limites específicos),\n", "eliminando a necessidade de decompor essas rotações em várias portas básicas.\n", "Ao aproveitar as interações nativas entre os qubits físicos, é possível implementar certas operações unitárias de forma mais eficiente no hardware.\n", "\n", "IBM As QPUs Quantum® Heron suportam as seguintes portas fracionárias:\n", "\n", "* $R_{ZZ}(\\theta)$ para $0 < \\theta < \\pi / 2$\n", "* $R_X(\\theta)$ para qualquer valor real $\\theta$\n", "\n", "Essas portas podem reduzir significativamente a profundidade e a duração dos circuitos quânticos.\n", "Eles são particularmente vantajosos em aplicativos que dependem muito de $R_{ZZ}$ e $R_X$, como a simulação Hamiltoniana, o Algoritmo de Otimização Aproximada Quântica (QAOA) e os métodos de kernel quântico.\n", "Neste tutorial, vamos nos concentrar no kernel quântico como um exemplo prático.\n", "\n" ] }, { "cell_type": "markdown", "id": "fe5675f3", "metadata": {}, "source": [ "\n", "\n", "### Limitações\n", "\n", "Atualmente, as portas fracionárias são um recurso experimental e apresentam algumas restrições:\n", "\n", "* $R_{ZZ}$ é limitado a ângulos no intervalo $0 < \\theta < \\pi / 2$.\n", "* Não há suporte para o uso de portas fracionárias em [circuitos dinâmicos](/docs/guides/classical-feedforward-and-control-flow), [giro de Pauli](/docs/guides/error-mitigation-and-suppression-techniques#pauli-twirling), [cancelamento de erro probabilístico](/docs/guides/error-mitigation-and-suppression-techniques#probabilistic-error-cancellation-pec) (PEC) e [extrapolação de ruído zero](/docs/guides/error-mitigation-and-suppression-techniques#zero-noise-extrapolation-zne) (ZNE) (usando [amplificação de erro probabilístico](/docs/guides/error-mitigation-and-suppression-techniques#probabilistic-error-amplification-pea) (PEA)).\n", "\n", "As portas fracionárias exigem um fluxo de trabalho diferente em comparação com a abordagem padrão.\n", "Este tutorial explica como trabalhar com portas fracionárias por meio de um aplicativo prático.\n", "\n", "Consulte o seguinte para obter mais detalhes sobre portas fracionárias.\n", "\n", "* [Portas fracionárias](/docs/guides/fractional-gates)\n", "* [Quando *não* usar portas fracionárias](/docs/guides/fractional-gates#when-not-to-use)\n", "\n" ] }, { "cell_type": "markdown", "id": "a4bdab87", "metadata": {}, "source": [ "\n", "\n", "### Abordagens de fluxo de trabalho para a restrição do ângulo RZZ\n", "\n" ] }, { "cell_type": "markdown", "id": "db213506", "metadata": {}, "source": [ "O fluxo de trabalho para o uso de portas fracionárias geralmente segue o fluxo de trabalho [dos padrões do Qiskit](/docs/guides/intro-to-patterns).\n", "A principal diferença é que todos os ângulos RZZ devem satisfazer a restrição $0 < \\theta \\leq \\pi/2$.\n", "Existem duas abordagens para garantir que essa condição seja atendida, conforme discutiremos a seguir. Recomendamos a segunda abordagem e, neste tutorial, a demonstramos por meio de um exemplo inspirado no método do kernel quântico.\n", "Para entender melhor em que contextos os kernels quânticos podem ser úteis, recomendamos a leitura [do artigo de Liu, Arunachalam e Temme (2021)](https://www.nature.com/articles/s41567-021-01287-z).\n", "\n", "Você também pode seguir o tutorial [de treinamento sobre kernels quânticos](/docs/tutorials/quantum-kernel-training) e a aula [sobre kernels quânticos](/learning/courses/quantum-machine-learning/quantum-kernel-methods) no curso de aprendizado de máquina quântico em IBM Quantum® Learning.\n", "\n" ] }, { "cell_type": "markdown", "id": "5797ed7e", "metadata": {}, "source": [ "\n", "\n", "#### 1. Gerar valores de parâmetros que satisfaçam a restrição do ângulo RZZ\n", "\n", "Se você tiver certeza de que todos os ângulos RZZ estão dentro do intervalo válido, poderá seguir o fluxo de trabalho padrão dos padrões do Qiskit.\n", "Nesse caso, basta enviar os valores dos parâmetros como parte de um PUB. O fluxo de trabalho é realizado da seguinte forma.\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", "Se você tentar enviar um PUB que inclua uma porta RZZ com um ângulo fora do intervalo válido, receberá uma mensagem de erro como esta:\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 esse erro, utilize a segunda abordagem descrita a seguir.\n", "\n" ] }, { "cell_type": "markdown", "id": "d3e00f37", "metadata": {}, "source": [ "\n", "\n", "#### 2. Atribua valores de parâmetros aos circuitos antes da transpilagem\n", "\n", "O `qiskit-ibm-runtime` pacote oferece uma etapa de transpilador especializada chamada [`FoldRzzAngle`](/docs/api/qiskit-ibm-runtime/transpiler-passes-fold-rzz-angle).\n", "Esta etapa transforma os circuitos quânticos de forma que todos os ângulos RZZ estejam em conformidade com a restrição de ângulo RZZ.\n", "Se você fornecer o backend para `generate_preset_pass_manager` ou `transpile`, o Qiskit aplica `FoldRzzAngle` automaticamente aos circuitos quânticos.\n", "Essa abordagem exige que você atribua valores aos parâmetros dos circuitos quânticos antes da transpilagem.\n", "O fluxo de trabalho se desenrola da seguinte forma.\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", "Observe que esse fluxo de trabalho acarreta um custo computacional maior do que a primeira abordagem, pois envolve atribuir valores de parâmetros aos circuitos quânticos e armazenar localmente os circuitos associados a esses parâmetros.\n", "\n" ] }, { "cell_type": "markdown", "id": "b7cb1bd2", "metadata": {}, "source": [ "\n", " **Esteja ciente de um problema conhecido descrito em `qiskit-ibm-runtime`v0.47.0,** no qual portas RZZ com ângulos inválidos podem permanecer nos circuitos mesmo após a transpilacão, em certos cenários.\n", "\n", " Acesse [qiskit-ibm-runtime#2441](https://github.com/Qiskit/qiskit-ibm-runtime/issues/2441) para acompanhar o andamento dessa questão.\n", " Recomendamos a seguinte solução alternativa até que o problema seja resolvido.\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 iniciar este tutorial, verifique se você tem os seguintes itens instalados:\n", "\n", "* Qiskit SDK v2.0 ou posterior, com suporte [para visualização](/docs/api/qiskit/visualization)\n", "* Qiskit Runtime v0.41 ou posterior (`pip install qiskit-ibm-runtime`)\n", "* Qiskit Aer v0.17 ou versão posterior (`pip install qiskit-aer`)\n", "* Qiskit Basis Constructor (`pip install qiskit_basis_constructor`)\n", "\n" ] }, { "cell_type": "markdown", "id": "5f43ce5d", "metadata": {}, "source": [ "\n", "\n", "## Instalação\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", "### Habilite portas fracionárias e verifique portas básicas\n", "\n", "Para usar portas fracionárias, você pode obter um backend compatível com elas, definindo a opção `use_fractional_gates=True` .\n", "Se o backend for compatível com portas fracionárias, você verá `rzz` e `rx` listados entre suas portas de 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", "## Exemplo de simulador em pequena escala\n", "\n", "Nesta seção, vamos explicar as quatro etapas do fluxo de trabalho [do Qiskit Patterns](/docs/guides/intro-to-patterns) em um simulador, usando o circuito do kernel quântico como exemplo prático.\n", "\n" ] }, { "cell_type": "markdown", "id": "7bfd6a97", "metadata": {}, "source": [ "\n", "\n", "### Etapa 1: Mapeie entradas clássicas para um problema quântico\n", "\n", "\n", "\n", "#### Circuito de kernel quântico\n", "\n", "Nesta seção, exploramos o circuito do kernel quântico usando portas RZZ para introduzir o fluxo de trabalho para portas fracionárias.\n", "\n", "Começamos construindo um circuito quântico para computar entradas individuais da matriz do kernel.\n", "Isso é feito por meio da combinação de circuitos de mapas de recursos ZZ com uma sobreposição unitária.\n", "A função de kernel usa vetores no espaço mapeado de recursos e retorna seu produto interno como uma entrada da matriz de kernel: $K(x, y) = \\langle \\Phi(x) | \\Phi(y) \\rangle,$ onde $|\\Phi(x)\\rangle$ representa o estado quântico mapeado por recursos.\n", "\n", "Construímos manualmente um circuito de mapa de características ZZ utilizando portas RZZ.\n", "`zz_feature_map`Embora o Qiskit ofereça um recurso integrado, ele ainda não oferece suporte a portas RZZ, conforme indicado na página v2.4.1 do Qiskit ( [consulte a issue](https://github.com/Qiskit/qiskit/issues/14469) ).\n", "\n", "Em seguida, calculamos a função do kernel para entradas idênticas - por exemplo, $K(x, x) = 1$. Em computadores quânticos ruidosos, esse valor pode ser menor que 1 devido ao ruído.\n", "Um resultado mais próximo de 1 indica menor ruído na execução.\n", "Neste tutorial, nos referimos a esse valor como a *fidelidade*, 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": [ "Os circuitos de kernel quântico e seus valores de parâmetros correspondentes são gerados para sistemas com 4 a 40 qubits, e suas fidelidades são avaliadas posteriormente.\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": [ "O circuito de quatro qubits é visualizado abaixo.\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": [ "No fluxo de trabalho padrão dos padrões do Qiskit, os valores dos parâmetros são normalmente passados para o primitivo Sampler ou Estimator como parte de um PUB.\n", "No entanto, ao usar um backend que ofereça suporte a portas fracionárias, esses valores de parâmetros devem ser explicitamente atribuídos ao circuito quântico antes da transpilação.\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", "### Etapa 2: Otimizar o problema para execução em hardware quântico\n", "\n" ] }, { "cell_type": "markdown", "id": "804ba317", "metadata": {}, "source": [ "Em seguida, transpilamos o circuito usando o gerenciador de passagens seguindo o padrão Qiskit.\n", "Ao fornecer um backend compatível com portas fracionárias para `generate_preset_pass_manager`, uma passagem especializada chamada `FoldRzzAngle` é automaticamente incluída.\n", "Essa passagem modifica o circuito para atender às restrições de ângulo RZZ.\n", "Como resultado, as portas RZZ com valores negativos na figura anterior são transformadas em valores positivos, e algumas portas X adicionais são adicionadas.\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 avaliar o impacto das portas fracionárias, avaliamos o número de portas não locais (CZ e RZZ para esse backend), juntamente com as profundidades e durações dos circuitos, e comparamos essas métricas com as de um fluxo de trabalho padrão 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", "### Passo 3: Execute usando Qiskit primitives\n", "\n" ] }, { "cell_type": "markdown", "id": "87926539", "metadata": {}, "source": [ "Executamos o circuito transpilado com o backend que suporta portas fracionárias.\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", "### Etapa 4: Pós-processamento e retorno do resultado no formato clássico desejado\n", "\n" ] }, { "cell_type": "markdown", "id": "7a865036", "metadata": {}, "source": [ "Você pode obter o valor da função kernel $K(x, x)$ medindo a probabilidade do bitstring totalmente zero `00...00` na saída.\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", "### Comparação do fluxo de trabalho e do circuito sem portas fracionárias\n", "\n", "Nesta seção, apresentamos o fluxo de trabalho padrão do Qiskit Patterns utilizando um backend que não suporta portas fracionárias.\n", "Ao comparar os circuitos transpilados, você perceberá que a versão que utiliza portas fracionárias (da seção anterior) é mais compacta do que aquela sem portas fracionárias.\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", "### Comparação entre profundidades, durações e fidelidades\n", "\n", "Nesta seção, comparamos o número de portas não locais e as fidelidades entre os circuitos com e sem portas fracionárias.\n", "Isso destaca os possíveis benefícios do uso de portas fracionárias em termos de eficiência e qualidade de execução.\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", "## Exemplo de hardware em grande escala\n", "\n", "Nesta seção, comparamos o desempenho do fluxo de trabalho do kernel quântico com e sem portas fracionárias em hardware quântico com até 40 qubits.\n", "\n" ] }, { "cell_type": "markdown", "id": "fd68378c", "metadata": {}, "source": [ "\n", "\n", "### Etapas 1 a 4 combinadas\n", "\n", "O fluxo de trabalho segue a mesma estrutura do exemplo em pequena escala. Compilamos todos os circuitos, com e sem portas fracionárias, coletamos métricas e, em seguida, submetemos os circuitos a hardware quâ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": [ "Em seguida, comparamos as 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 o tempo de uso da QPU com e sem portas fracionárias. Os resultados na célula a seguir mostram que os tempos de uso da QPU são quase 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", "## Tópico avançado: Usando apenas portas RX fracionárias\n", "\n", "A necessidade de modificar o fluxo de trabalho ao usar portas fracionárias decorre principalmente da restrição dos ângulos de porta RZZ.\n", "No entanto, se você usar apenas as portas RX fracionárias e excluir as portas RZZ fracionárias, poderá continuar a seguir o fluxo de trabalho padrão dos padrões Qiskit.\n", "Essa abordagem ainda pode oferecer benefícios significativos, especialmente em circuitos que envolvem um grande número de portas RX e portas U, reduzindo o número total de portas e melhorando potencialmente o desempenho.\n", "Nesta seção, demonstramos como otimizar seus circuitos usando apenas portas RX fracionárias, omitindo as portas RZZ.\n", "\n", "Para dar suporte a isso, fornecemos uma função utilitária que permite desativar uma porta de base específica em um objeto Target.\n", "Aqui, nós o usamos para desativar as portas 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": [ "Usamos um circuito que consiste em portas U, CZ e RZZ como exemplo.\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": [ "Primeiro, transpilamos o circuito para um backend que não oferece suporte a portas fracionárias.\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": [ "Em seguida, transpilamos o mesmo circuito usando portas RX fracionárias, excluindo as portas RZZ.\n", "Isso resulta em uma pequena redução na contagem total de portas, graças à implementação mais eficiente das portas 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", "### Otimize portas U com portas RX fracionárias\n", "\n", "Nesta seção, demonstramos como otimizar as portas U usando portas RX fracionárias, com base no mesmo circuito apresentado na seção anterior.\n", "\n" ] }, { "cell_type": "markdown", "id": "3f73cbda", "metadata": {}, "source": [ "Transpilamos o circuito usando apenas portas RX fracionárias, excluindo as portas RZZ.\n", "Ao introduzir uma regra de decomposição personalizada, conforme mostrado a seguir, podemos reduzir o número de portas de um único qubit necessárias para implementar uma porta U.\n", "\n", "Esse recurso está atualmente em discussão nesta [questão](https://github.com/Qiskit/qiskit/issues/13455) do 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": [ "Em seguida, aplicamos o transpiler utilizando `constructor-beta` a tradução fornecida pelo `qiskit-basis-constructor` pacote.\n", "Como resultado, o número total de portas é reduzido em comparação com a transpilacão 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óximas etapas\n", "\n", "\n", " Se você achou este trabalho interessante, talvez se interesse pelo material a seguir:\n", "\n", " * Guia [sobre portas fracionárias](/docs/guides/fractional-gates)\n", " * [Quando *não* usar portas fracionárias](/docs/guides/fractional-gates#when-not-to-use)\n", " * [`FoldRzzAngle`](/docs/api/qiskit-ibm-runtime/transpiler-passes-fold-rzz-angle) Referência da API da etapa do transpiler\n", " * Tutorial [de treinamento do kernel](/docs/tutorials/quantum-kernel-training) do Quantum\n", " * A aula sobre [kernels quânticos](/learning/courses/quantum-machine-learning/quantum-kernel-methods) no curso de aprendizado de máquina quâ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 }