{ "cells": [ { "cell_type": "markdown", "id": "a0f5b3c9-754e-47d4-8dc7-5af247070187", "metadata": {}, "source": [ "---\n", "title: \"Crie e transpile em backends personalizados\"\n", "description: \"Aprenda a criar seus próprios backends personalizados e transpilar circuitos com base neles\"\n", "---\n", "\n", "{/* cspell:ignore multichip interchip Lasciate ogne speranza voi ch'intrate */}\n", "\n" ] }, { "cell_type": "markdown", "id": "9429c31d-84b1-4547-9227-0b2fcf8a0193", "metadata": {}, "source": [ "\n", "\n", "# Crie e transpile em backends personalizados\n", "\n" ] }, { "cell_type": "markdown", "id": "27349ef1-5e25-4762-8a6f-8b4c265763c9", "metadata": { "tags": [ "version-info" ] }, "source": [ "{/*\n", " DO NOT EDIT THIS CELL!!!\n", " This cell's content is generated automatically by a script. Anything you add\n", " here will be removed next time the notebook is run. To add new content, create\n", " a new cell before or after this one.\n", " */}\n", "\n", "\n", " \n", " O código desta página foi desenvolvido usando os seguintes requisitos.\n", " Recomendamos o uso dessas versões ou de versões mais recentes.\n", "\n", " ```\n", " qiskit[all]~=2.5.0\n", " ```\n", " \n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "678c28a1-d1ee-4179-8c7a-be5698e045bb", "metadata": {}, "source": [ "{/* cspell:ignore LOCC */}\n", "\n", "Um dos recursos mais avançados do Qiskit é a capacidade de oferecer suporte a configurações exclusivas de dispositivos. O Qiskit foi desenvolvido para ser independente do fornecedor do hardware quântico que você usa, e os fornecedores podem configurar o objeto `BackendV2` de acordo com as propriedades exclusivas de seus próprios dispositivos. Este tópico demonstra como configurar seu próprio backend e transpilar circuitos quânticos para ele.\n", "\n", "Você pode criar objetos `BackendV2` exclusivos com diferentes geometrias ou portas de base e transpilar seus circuitos com essas configurações em mente. O exemplo abaixo abrange um backend com uma rede de qubit disjunta, cujas portas de base são diferentes ao longo das bordas de dentro do volume.\n", "\n" ] }, { "cell_type": "markdown", "id": "77d43aaf-5f92-412d-b49a-30be82268d21", "metadata": {}, "source": [ "\n", "\n", "## Entenda as interfaces Provider, BackendV2 e Target\n", "\n", "Antes de começar, é útil entender o uso e a finalidade do [`Provider`](../api/qiskit/providers), [`BackendV2`](../api/qiskit/qiskit.providers.BackendV2), e [`Target`](../api/qiskit/qiskit.transpiler.Target) objetos.\n", "\n", "* Se você tiver um dispositivo ou simulador quântico que deseja integrar ao Qiskit SDK, precisará escrever sua própria classe `Provider` . Essa classe tem uma única finalidade: obter objetos de back-end fornecidos por você. É aqui que todas as tarefas de credenciais e/ou autenticação necessárias são tratadas. Uma vez instanciado, o objeto do provedor fornecerá uma lista de back-ends, bem como a capacidade de adquirir/instanciar back-ends.\n", "\n", "* Em seguida, as classes de back-end fornecem a interface entre o Qiskit SDK e o hardware ou simulador que executará os circuitos. Eles incluem todas as informações necessárias para descrever um backend para o transpilador, de modo que ele possa otimizar qualquer circuito de acordo com suas restrições. O site `BackendV2` é composto de quatro partes principais:\n", " * A [`Target`](../api/qiskit/qiskit.transpiler.Target) que contém uma descrição das restrições do backend e fornece um modelo do backend para o transpilador\n", " * Uma propriedade do site `max_circuits` que define um limite para o número de circuitos que um backend pode executar em um único trabalho\n", " * Um método `run()` que aceita envios de trabalhos\n", " * Um conjunto de `_default_options` para definir as opções configuráveis pelo usuário e seus valores padrão\n", "\n" ] }, { "cell_type": "markdown", "id": "0ad9dc45-97e9-4e47-b7c0-2fa536d4e624", "metadata": {}, "source": [ "\n", "\n", "## Crie um arquivo personalizado BackendV2\n", "\n", "O objeto `BackendV2` é uma classe abstrata usada para todos os objetos de backend criados por um provedor (em `qiskit.providers` ou em outra biblioteca, como [`qiskit_ibm_runtime.IBMBackend`](../api/qiskit-ibm-runtime/ibm-backend)). Como mencionado acima, esses objetos contêm vários atributos, incluindo um atributo [`Target`](/docs/api/qiskit/qiskit.transpiler.Target). O site `Target` contém informações que especificam os atributos do backend, como a lista [`Coupling Map`](/docs/api/qiskit/qiskit.transpiler.CouplingMap), lista de [`Instructions`](/docs/api/qiskit/qiskit.circuit.Instruction)e outros - para o transpilador. Além do `Target`, também é possível definir detalhes em nível de pulso, como o [`DriveChannel`](/docs/api/qiskit/1.4/qiskit.pulse.channels.DriveChannel) ou [`ControlChannel`](/docs/api/qiskit/1.4/qiskit.pulse.channels.ControlChannel).\n", "\n", "O exemplo a seguir demonstra essa personalização criando um backend simulado de vários chips, em que cada chip possui uma conectividade heavy-hex. O exemplo especifica que o conjunto de portas de dois qubits do backend é [`CZGates`](../api/qiskit/qiskit.circuit.library.CZGate) dentro de cada chip e [`CXGates`](../api/qiskit/qiskit.circuit.library.ECRGate) entre os chips. Primeiro, crie seu próprio site `BackendV2` e personalize-o `Target` com portas de um e dois qubits de acordo com as restrições descritas anteriormente.\n", "\n", "\n", " A plotagem de um mapa de acoplamento requer que a biblioteca [`graphviz`](https://graphviz.org/) esteja instalada.\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "b346f50b-b127-4074-99fc-7c53e3fbc022", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import rustworkx as rx\n", "\n", "from qiskit.providers import BackendV2, Options\n", "from qiskit.transpiler import Target, InstructionProperties\n", "from qiskit.circuit.library import XGate, SXGate, RZGate, CZGate, ECRGate\n", "from qiskit.circuit import Measure, Delay, Parameter, Reset\n", "from qiskit import QuantumCircuit, transpile\n", "from qiskit.visualization import plot_gate_map\n", "\n", "\n", "class FakeLOCCBackend(BackendV2):\n", " \"\"\"Fake multi chip backend.\"\"\"\n", "\n", " def __init__(self, distance=3, number_of_chips=3):\n", " \"\"\"Instantiate a new fake multi chip backend.\n", "\n", " Args:\n", " distance (int): The heavy hex code distance to use for each chips'\n", " coupling map. This number **must** be odd. The distance relates\n", " to the number of qubits by:\n", " :math:`n = \\\\frac{5d^2 - 2d - 1}{2}` where :math:`n` is the\n", " number of qubits and :math:`d` is the ``distance``\n", " number_of_chips (int): The number of chips to have in the multichip backend\n", " each chip will be a heavy hex graph of ``distance`` code distance.\n", " \"\"\"\n", " super().__init__(name=\"Fake LOCC backend\")\n", " # Create a heavy-hex graph using the\n", " # rustworkx library, then instantiate a new target\n", " self._graph = rx.generators.directed_heavy_hex_graph(\n", " distance, bidirectional=False\n", " )\n", " num_qubits = len(self._graph) * number_of_chips\n", " self._target = Target(\n", " \"Fake multi-chip backend\", num_qubits=num_qubits\n", " )\n", "\n", " # Generate instruction properties for single qubit gates and a measurement, delay,\n", " # and reset operation to every qubit in the backend.\n", " rng = np.random.default_rng(seed=12345678942)\n", " rz_props = {}\n", " x_props = {}\n", " sx_props = {}\n", " measure_props = {}\n", " delay_props = {}\n", "\n", " # Add 1q gates. Globally use virtual rz, x, sx, and measure\n", " for i in range(num_qubits):\n", " qarg = (i,)\n", " rz_props[qarg] = InstructionProperties(error=0.0, duration=0.0)\n", " x_props[qarg] = InstructionProperties(\n", " error=rng.uniform(1e-6, 1e-4),\n", " duration=rng.uniform(1e-8, 9e-7),\n", " )\n", " sx_props[qarg] = InstructionProperties(\n", " error=rng.uniform(1e-6, 1e-4),\n", " duration=rng.uniform(1e-8, 9e-7),\n", " )\n", " measure_props[qarg] = InstructionProperties(\n", " error=rng.uniform(1e-3, 1e-1),\n", " duration=rng.uniform(1e-8, 9e-7),\n", " )\n", " delay_props[qarg] = None\n", " self._target.add_instruction(XGate(), x_props)\n", " self._target.add_instruction(SXGate(), sx_props)\n", " self._target.add_instruction(RZGate(Parameter(\"theta\")), rz_props)\n", " self._target.add_instruction(Measure(), measure_props)\n", " self._target.add_instruction(Reset(), measure_props)\n", "\n", " self._target.add_instruction(Delay(Parameter(\"t\")), delay_props)\n", " # Add chip local 2q gate which is CZ\n", " cz_props = {}\n", " for i in range(number_of_chips):\n", " for root_edge in self._graph.edge_list():\n", " offset = i * len(self._graph)\n", " edge = (root_edge[0] + offset, root_edge[1] + offset)\n", " cz_props[edge] = InstructionProperties(\n", " error=rng.uniform(7e-4, 5e-3),\n", " duration=rng.uniform(1e-8, 9e-7),\n", " )\n", " self._target.add_instruction(CZGate(), cz_props)\n", "\n", " cx_props = {}\n", " # Add interchip 2q gates which are ecr (effectively CX)\n", " # First determine which nodes to connect\n", " node_indices = self._graph.node_indices()\n", " edge_list = self._graph.edge_list()\n", " inter_chip_nodes = {}\n", " for node in node_indices:\n", " count = 0\n", " for edge in edge_list:\n", " if node == edge[0]:\n", " count += 1\n", " if count == 1:\n", " inter_chip_nodes[node] = count\n", " # Create inter-chip ecr props\n", " cx_props = {}\n", " inter_chip_edges = list(inter_chip_nodes.keys())\n", " for i in range(1, number_of_chips):\n", " offset = i * len(self._graph)\n", " edge = (\n", " inter_chip_edges[1] + (len(self._graph) * (i - 1)),\n", " inter_chip_edges[0] + offset,\n", " )\n", " cx_props[edge] = InstructionProperties(\n", " error=rng.uniform(7e-4, 5e-3),\n", " duration=rng.uniform(1e-8, 9e-7),\n", " )\n", "\n", " self._target.add_instruction(ECRGate(), cx_props)\n", "\n", " @property\n", " def target(self):\n", " return self._target\n", "\n", " @property\n", " def max_circuits(self):\n", " return None\n", "\n", " @property\n", " def graph(self):\n", " return self._graph\n", "\n", " @classmethod\n", " def _default_options(cls):\n", " return Options(shots=1024)\n", "\n", " def run(self, circuit, **kwargs):\n", " raise NotImplementedError(\n", " \"This backend does not contain a run method\"\n", " )" ] }, { "cell_type": "markdown", "id": "64a418fa-7a7e-4a12-b9c9-ff7377bffed4", "metadata": {}, "source": [ "\n", "\n", "### Visualizar backends\n", "\n", "Você pode visualizar o gráfico de conectividade dessa nova classe com o método [`plot_gate_map()`](../api/qiskit/qiskit.visualization.plot_gate_map) do módulo `qiskit.visualization` . Esse método, juntamente com [`plot_coupling_map()`](../api/qiskit/qiskit.visualization.plot_coupling_map) e [`plot_circuit_layout()`](../api/qiskit/qiskit.visualization.plot_circuit_layout)são ferramentas úteis para visualizar a disposição dos qubits de um backend, bem como a forma como um circuito é disposto nos qubits de um backend. Este exemplo cria um backend contendo três pequenos chips heavy-hex. Ele especifica um conjunto de coordenadas para organizar os qubits, bem como um conjunto de cores personalizadas para os diferentes portões de dois qubits.\n", "\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "fcc3056a-4e89-4b35-a0d5-e5c676459cc2", "metadata": {}, "outputs": [], "source": [ "backend = FakeLOCCBackend(3, 3)\n", "\n", "\n", "target = backend.target\n", "coupling_map_backend = target.build_coupling_map()\n", "\n", "\n", "coordinates = [\n", " (3, 1),\n", " (3, -1),\n", " (2, -2),\n", " (1, 1),\n", " (0, 0),\n", " (-1, -1),\n", " (-2, 2),\n", " (-3, 1),\n", " (-3, -1),\n", " (2, 1),\n", " (1, -1),\n", " (-1, 1),\n", " (-2, -1),\n", " (3, 0),\n", " (2, -1),\n", " (0, 1),\n", " (0, -1),\n", " (-2, 1),\n", " (-3, 0),\n", "]\n", "\n", "single_qubit_coordinates = []\n", "total_qubit_coordinates = []\n", "\n", "\n", "for coordinate in coordinates:\n", " total_qubit_coordinates.append(coordinate)\n", "\n", "for coordinate in coordinates:\n", " total_qubit_coordinates.append(\n", " (-1 * coordinate[0] + 1, coordinate[1] + 4)\n", " )\n", "\n", "for coordinate in coordinates:\n", " total_qubit_coordinates.append((coordinate[0], coordinate[1] + 8))\n", "\n", "\n", "line_colors = [\"#adaaab\" for edge in coupling_map_backend.get_edges()]\n", "ecr_edges = []\n", "\n", "# Get tuples for the edges which have an ecr instruction attached\n", "for instruction in target.instructions:\n", " if instruction[0].name == \"ecr\":\n", " ecr_edges.append(instruction[1])\n", "\n", "for i, edge in enumerate(coupling_map_backend.get_edges()):\n", " if edge in ecr_edges:\n", " line_colors[i] = \"#000000\"" ] }, { "cell_type": "code", "execution_count": 4, "id": "6dc04d04-7afb-46f2-8ee6-ac961e4583f5", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Fake LOCC backend\n" ] }, { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "print(backend.name)\n", "plot_gate_map(\n", " backend,\n", " plot_directed=True,\n", " qubit_coordinates=total_qubit_coordinates,\n", " line_color=line_colors,\n", ")" ] }, { "cell_type": "markdown", "id": "d61da191-caa0-4175-a5f4-741b60905cdc", "metadata": {}, "source": [ "Cada qubit é rotulado e as setas coloridas representam as portas de dois qubits. As setas cinzas são as portas CZ e as setas pretas são as portas CX entre chips (elas conectam os qubits $6 \\rightarrow 21$ e $25 \\rightarrow 40$ ). A direção da seta indica a direção padrão em que essas portas são executadas; elas especificam quais qubits são controle/alvos por padrão para cada canal de dois qubits.\n", "\n" ] }, { "cell_type": "markdown", "id": "59dc66df-5fb8-4844-922c-714fa86f08d5", "metadata": {}, "source": [ "\n", "\n", "\n", "\n", "## Transpilar contra backends personalizados\n", "\n", "Agora que um backend personalizado com seu próprio e exclusivo [`Target`](../api/qiskit/qiskit.transpiler.Target) foi definido, é fácil transpilar circuitos quânticos para esse backend, pois todas as restrições relevantes (portas de base, conectividade de qubit e assim por diante) necessárias para as passagens do transpilador estão contidas nesse atributo. O próximo exemplo constrói um circuito que cria um estado GHZ grande e o transpila para o backend construído acima.\n", "\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "cf2b1e0f-e6a1-4274-af7b-e5d4d3df6add", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Pre-Transpilation: \n", "CX gates: 49\n", "H gates: 50\n", "\n", " ############################## \n", "\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Post-Transpilation: \n", "CZ gates: 204\n", "ECR gates: 8\n", "SX gates: 374\n", "RZ gates: 215\n" ] } ], "source": [ "from qiskit.transpiler import generate_preset_pass_manager\n", "\n", "num_qubits = 50\n", "ghz = QuantumCircuit(num_qubits)\n", "ghz.h(range(num_qubits))\n", "ghz.cx(0, range(1, num_qubits))\n", "op_counts = ghz.count_ops()\n", "\n", "print(\"Pre-Transpilation: \")\n", "print(f\"CX gates: {op_counts['cx']}\")\n", "print(f\"H gates: {op_counts['h']}\")\n", "print(\"\\n\", 30 * \"#\", \"\\n\")\n", "\n", "pm = generate_preset_pass_manager(optimization_level=3, backend=backend)\n", "transpiled_ghz = pm.run(ghz)\n", "op_counts = transpiled_ghz.count_ops()\n", "\n", "print(\"Post-Transpilation: \")\n", "print(f\"CZ gates: {op_counts['cz']}\")\n", "print(f\"ECR gates: {op_counts['ecr']}\")\n", "print(f\"SX gates: {op_counts['sx']}\")\n", "print(f\"RZ gates: {op_counts['rz']}\")" ] }, { "cell_type": "markdown", "id": "58625e26-e078-4ee6-8549-362762450a3b", "metadata": {}, "source": [ "O circuito transposto agora contém uma mistura de `CZ` portas `ECR` e, que especificamos como portas básicas no backend `Target`. Há também muito mais portas do que quando você começou, devido à necessidade de inserir instruções SWAP após escolher um layout. Abaixo, a ferramenta [`plot_circuit_layout()`](/docs/api/qiskit/qiskit.visualization.plot_circuit_layout) de visualização é usada para especificar quais qubits e canais de dois qubits foram usados neste circuito.\n", "\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "b51657ed-bb37-4e1a-9dea-8189b4229d24", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.visualization import plot_circuit_layout\n", "\n", "plot_circuit_layout(\n", " transpiled_ghz, backend, qubit_coordinates=total_qubit_coordinates\n", ")" ] }, { "cell_type": "markdown", "id": "ec002958-7eda-4329-aabb-cdf1b4c61403", "metadata": {}, "source": [ "\n", "\n", "## Crie backends exclusivos\n", "\n", "O pacote [rustworkx](https://www.rustworkx.org/) contém uma grande biblioteca de gráficos diferentes e permite a criação de gráficos personalizados. O código visualmente interessante abaixo cria um backend inspirado no código tórico. Em seguida, é possível visualizar o backend usando as funções da seção [Visualizar backends](#visualize-backends).\n", "\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "82b8fa47-b37f-4136-9e3a-ffa5bc72fdf5", "metadata": {}, "outputs": [], "source": [ "class FakeTorusBackend(BackendV2):\n", " \"\"\"Fake multi chip backend.\"\"\"\n", "\n", " def __init__(self):\n", " \"\"\"Instantiate a new backend that is inspired by a toric code\"\"\"\n", " super().__init__(name=\"Fake LOCC backend\")\n", " graph = rx.generators.directed_grid_graph(20, 20)\n", " for column in range(20):\n", " graph.add_edge(column, 19 * 20 + column, None)\n", " for row in range(20):\n", " graph.add_edge(row * 20, row * 20 + 19, None)\n", " num_qubits = len(graph)\n", " rng = np.random.default_rng(seed=12345678942)\n", " rz_props = {}\n", " x_props = {}\n", " sx_props = {}\n", " measure_props = {}\n", " delay_props = {}\n", " self._target = Target(\"Fake Kookaburra\", num_qubits=num_qubits)\n", " # Add 1q gates. Globally use virtual rz, x, sx, and measure\n", " for i in range(num_qubits):\n", " qarg = (i,)\n", " rz_props[qarg] = InstructionProperties(error=0.0, duration=0.0)\n", " x_props[qarg] = InstructionProperties(\n", " error=rng.uniform(1e-6, 1e-4),\n", " duration=rng.uniform(1e-8, 9e-7),\n", " )\n", " sx_props[qarg] = InstructionProperties(\n", " error=rng.uniform(1e-6, 1e-4),\n", " duration=rng.uniform(1e-8, 9e-7),\n", " )\n", " measure_props[qarg] = InstructionProperties(\n", " error=rng.uniform(1e-3, 1e-1),\n", " duration=rng.uniform(1e-8, 9e-7),\n", " )\n", " delay_props[qarg] = None\n", " self._target.add_instruction(XGate(), x_props)\n", " self._target.add_instruction(SXGate(), sx_props)\n", " self._target.add_instruction(RZGate(Parameter(\"theta\")), rz_props)\n", " self._target.add_instruction(Measure(), measure_props)\n", " self._target.add_instruction(Reset(), measure_props)\n", " self._target.add_instruction(Delay(Parameter(\"t\")), delay_props)\n", " cz_props = {}\n", " for edge in graph.edge_list():\n", " cz_props[edge] = InstructionProperties(\n", " error=rng.uniform(7e-4, 5e-3),\n", " duration=rng.uniform(1e-8, 9e-7),\n", " )\n", " self._target.add_instruction(CZGate(), cz_props)\n", "\n", " @property\n", " def target(self):\n", " return self._target\n", "\n", " @property\n", " def max_circuits(self):\n", " return None\n", "\n", " @classmethod\n", " def _default_options(cls):\n", " return Options(shots=1024)\n", "\n", " def run(self, circuit, **kwargs):\n", " raise NotImplementedError(\"Lasciate ogne speranza, voi ch'intrate\")" ] }, { "cell_type": "code", "execution_count": 8, "id": "1d40864a-7695-438b-95bf-7724c34d92b4", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "backend = FakeTorusBackend()\n", "# We set `figsize` to a smaller size to make the documentation website faster\n", "# to load. Normally, you do not need to set the argument.\n", "plot_gate_map(backend, figsize=(4, 4))" ] }, { "cell_type": "code", "execution_count": 9, "id": "341a0256-4a76-4d84-b598-5fc4d9fbef19", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CZ gates: 563\n", "X gates: 6\n", "SX gates: 1182\n", "RZ gates: 1078\n" ] } ], "source": [ "num_qubits = int(backend.num_qubits / 2)\n", "full_device_bv = QuantumCircuit(num_qubits, num_qubits - 1)\n", "full_device_bv.x(num_qubits - 1)\n", "full_device_bv.h(range(num_qubits))\n", "full_device_bv.cx(range(num_qubits - 1), num_qubits - 1)\n", "full_device_bv.h(range(num_qubits))\n", "full_device_bv.measure(range(num_qubits - 1), range(num_qubits - 1))\n", "tqc = transpile(full_device_bv, backend, optimization_level=3)\n", "op_counts = tqc.count_ops()\n", "print(f\"CZ gates: {op_counts['cz']}\")\n", "print(f\"X gates: {op_counts['x']}\")\n", "print(f\"SX gates: {op_counts['sx']}\")\n", "print(f\"RZ gates: {op_counts['rz']}\")" ] }, { "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 }