Crear y transpilación contra backends personalizados

El código de esta página se ha desarrollado teniendo en cuenta los siguientes requisitos. Recomendamos utilizar estas versiones o versiones más recientes.
```
qiskit[all]~=2.5.0
```

Una de las características más potentes de Qiskit es su capacidad para admitir configuraciones de dispositivo únicas. Qiskit está construido para ser agnóstico al proveedor del hardware cuántico que se utilice, y los proveedores pueden configurar el objeto BackendV2 a sus propias propiedades de dispositivo únicas. Este tema demuestra cómo configurar tu propio backend y transpilar circuitos cuánticos contra ellos.

Puede crear objetos BackendV2 únicos con diferentes geometrías o puertas base y transpilar sus circuitos teniendo en cuenta esas configuraciones. El ejemplo siguiente cubre un backend con un entramado de qubits disjuntos, cuyas puertas de base son diferentes a lo largo de los bordes desde dentro de la masa.

Comprender las interfaces Provider, BackendV2 y Target

Antes de empezar, es útil comprender el uso y la finalidad de la tecla Provider, BackendV2y Target objetos.

Si tienes un dispositivo cuántico o un simulador que quieres integrar en el SDK de Qiskit, tienes que escribir tu propia clase Provider . Esta clase tiene un único propósito: obtener los objetos backend que tú le proporciones. Aquí es donde se gestionan todas las tareas de credenciales y/o autenticación necesarias. Una vez instanciado, el objeto proveedor proporcionará una lista de backends, así como la capacidad de adquirir/instanciar backends.
A continuación, las clases backend proporcionan la interfaz entre el SDK de Qiskit y el hardware o simulador que ejecutará los circuitos. Incluyen toda la información necesaria para describir un backend al transpilador, de modo que pueda optimizar cualquier circuito en función de sus restricciones. BackendV2 consta de cuatro partes principales:
- A Target que contiene una descripción de las restricciones del backend y proporciona un modelo del backend para el transpilador
- Una propiedad de max_circuits que define un límite en el número de circuitos que un backend puede ejecutar en un único trabajo
- Un método run() que acepta el envío de trabajos
- Un conjunto de _default_options para definir las opciones configurables por el usuario y sus valores por defecto

Crear un BackendV2 personalizado

El objeto BackendV2 es una clase abstracta utilizada para todos los objetos backend creados por un proveedor (ya sea dentro de qiskit.providers o de otra biblioteca como qiskit_ibm_runtime.IBMBackend). Como ya se ha mencionado, estos objetos contienen varios atributos, entre los que se incluye un atributo Target. La dirección Target contiene información que especifica los atributos del backend - como la etiqueta Coupling Maplista de Instructionsy otros- al transpilador. Además de Target, también se pueden definir detalles a nivel de pulso como el DriveChannel o ControlChannel.

El siguiente ejemplo demuestra esta personalización mediante la creación de un backend multi-chip simulado, donde cada chip posee una conectividad heavy-hex. El ejemplo especifica que el conjunto de puertas de dos qubits del backend sea CZGates dentro de cada chip y CXGates entre chips. En primer lugar, cree su propio BackendV2 y personalice su Target con puertas de uno y dos qubits de acuerdo con las restricciones descritas anteriormente.

biblioteca graphviz

Para trazar un mapa de acoplamiento es necesario tener instalada la biblioteca graphviz esté instalada.

import numpy as np
import rustworkx as rx

from qiskit.providers import BackendV2, Options
from qiskit.transpiler import Target, InstructionProperties
from qiskit.circuit.library import XGate, SXGate, RZGate, CZGate, ECRGate
from qiskit.circuit import Measure, Delay, Parameter, Reset
from qiskit import QuantumCircuit, transpile
from qiskit.visualization import plot_gate_map


class FakeLOCCBackend(BackendV2):
    """Fake multi chip backend."""

    def __init__(self, distance=3, number_of_chips=3):
        """Instantiate a new fake multi chip backend.

        Args:
            distance (int): The heavy hex code distance to use for each chips'
                coupling map. This number **must** be odd. The distance relates
                to the number of qubits by:
                :math:`n = \\frac{5d^2 - 2d - 1}{2}` where :math:`n` is the
                number of qubits and :math:`d` is the ``distance``
            number_of_chips (int): The number of chips to have in the multichip backend
                each chip will be a heavy hex graph of ``distance`` code distance.
        """
        super().__init__(name="Fake LOCC backend")
        # Create a heavy-hex graph using the
        # rustworkx library, then instantiate a new target
        self._graph = rx.generators.directed_heavy_hex_graph(
            distance, bidirectional=False
        )
        num_qubits = len(self._graph) * number_of_chips
        self._target = Target(
            "Fake multi-chip backend", num_qubits=num_qubits
        )

        # Generate instruction properties for single qubit gates and a measurement, delay,
        #  and reset operation to every qubit in the backend.
        rng = np.random.default_rng(seed=12345678942)
        rz_props = {}
        x_props = {}
        sx_props = {}
        measure_props = {}
        delay_props = {}

        # Add 1q gates. Globally use virtual rz, x, sx, and measure
        for i in range(num_qubits):
            qarg = (i,)
            rz_props[qarg] = InstructionProperties(error=0.0, duration=0.0)
            x_props[qarg] = InstructionProperties(
                error=rng.uniform(1e-6, 1e-4),
                duration=rng.uniform(1e-8, 9e-7),
            )
            sx_props[qarg] = InstructionProperties(
                error=rng.uniform(1e-6, 1e-4),
                duration=rng.uniform(1e-8, 9e-7),
            )
            measure_props[qarg] = InstructionProperties(
                error=rng.uniform(1e-3, 1e-1),
                duration=rng.uniform(1e-8, 9e-7),
            )
            delay_props[qarg] = None
        self._target.add_instruction(XGate(), x_props)
        self._target.add_instruction(SXGate(), sx_props)
        self._target.add_instruction(RZGate(Parameter("theta")), rz_props)
        self._target.add_instruction(Measure(), measure_props)
        self._target.add_instruction(Reset(), measure_props)

        self._target.add_instruction(Delay(Parameter("t")), delay_props)
        # Add chip local 2q gate which is CZ
        cz_props = {}
        for i in range(number_of_chips):
            for root_edge in self._graph.edge_list():
                offset = i * len(self._graph)
                edge = (root_edge[0] + offset, root_edge[1] + offset)
                cz_props[edge] = InstructionProperties(
                    error=rng.uniform(7e-4, 5e-3),
                    duration=rng.uniform(1e-8, 9e-7),
                )
        self._target.add_instruction(CZGate(), cz_props)

        cx_props = {}
        # Add interchip 2q gates which are ecr (effectively CX)
        # First determine which nodes to connect
        node_indices = self._graph.node_indices()
        edge_list = self._graph.edge_list()
        inter_chip_nodes = {}
        for node in node_indices:
            count = 0
            for edge in edge_list:
                if node == edge[0]:
                    count += 1
            if count == 1:
                inter_chip_nodes[node] = count
        # Create inter-chip ecr props
        cx_props = {}
        inter_chip_edges = list(inter_chip_nodes.keys())
        for i in range(1, number_of_chips):
            offset = i * len(self._graph)
            edge = (
                inter_chip_edges[1] + (len(self._graph) * (i - 1)),
                inter_chip_edges[0] + offset,
            )
            cx_props[edge] = InstructionProperties(
                error=rng.uniform(7e-4, 5e-3),
                duration=rng.uniform(1e-8, 9e-7),
            )

        self._target.add_instruction(ECRGate(), cx_props)

    @property
    def target(self):
        return self._target

    @property
    def max_circuits(self):
        return None

    @property
    def graph(self):
        return self._graph

    @classmethod
    def _default_options(cls):
        return Options(shots=1024)

    def run(self, circuit, **kwargs):
        raise NotImplementedError(
            "This backend does not contain a run method"
        )

Visualizar backends

Puedes ver el gráfico de conectividad de esta nueva clase con el método plot_gate_map() del módulo qiskit.visualization . Este método, junto con plot_coupling_map() y plot_circuit_layout()son herramientas útiles para visualizar la disposición de los qubits de un backend, así como la disposición de un circuito a través de los qubits de un backend. Este ejemplo crea un backend que contiene tres pequeñas fichas de hexágono grueso. Especifica un conjunto de coordenadas para disponer los qubits, así como un conjunto de colores personalizados para las diferentes puertas de dos qubits.

backend = FakeLOCCBackend(3, 3)


target = backend.target
coupling_map_backend = target.build_coupling_map()


coordinates = [
    (3, 1),
    (3, -1),
    (2, -2),
    (1, 1),
    (0, 0),
    (-1, -1),
    (-2, 2),
    (-3, 1),
    (-3, -1),
    (2, 1),
    (1, -1),
    (-1, 1),
    (-2, -1),
    (3, 0),
    (2, -1),
    (0, 1),
    (0, -1),
    (-2, 1),
    (-3, 0),
]

single_qubit_coordinates = []
total_qubit_coordinates = []


for coordinate in coordinates:
    total_qubit_coordinates.append(coordinate)

for coordinate in coordinates:
    total_qubit_coordinates.append(
        (-1 * coordinate[0] + 1, coordinate[1] + 4)
    )

for coordinate in coordinates:
    total_qubit_coordinates.append((coordinate[0], coordinate[1] + 8))


line_colors = ["#adaaab" for edge in coupling_map_backend.get_edges()]
ecr_edges = []

# Get tuples for the edges which have an ecr instruction attached
for instruction in target.instructions:
    if instruction[0].name == "ecr":
        ecr_edges.append(instruction[1])

for i, edge in enumerate(coupling_map_backend.get_edges()):
    if edge in ecr_edges:
        line_colors[i] = "#000000"

print(backend.name)
plot_gate_map(
    backend,
    plot_directed=True,
    qubit_coordinates=total_qubit_coordinates,
    line_color=line_colors,
)

Output:

Fake LOCC backend

Cada qubit está etiquetado y las flechas de color representan las puertas de dos qubits. Las flechas grises son las compuertas CZ y las flechas negras son las compuertas inter-chip CX (conectan los qubits $6 \rightarrow 21$ y $25 \rightarrow 40$ ). La dirección de la flecha indica la dirección por defecto en la que se ejecutan estas puertas; especifican qué qubits son control/objetivo por defecto para cada canal de dos qubits.

Transpilar contra backends personalizados

Ahora que se ha definido un backend personalizado con su propio y único Target es sencillo transpilar circuitos cuánticos contra este backend, ya que todas las restricciones relevantes (puertas base, conectividad qubit, etc.) necesarias para los pases del transpilador están contenidas en este atributo. El siguiente ejemplo construye un circuito que crea un estado GHZ grande y lo transpila contra el backend construido anteriormente.

from qiskit.transpiler import generate_preset_pass_manager

num_qubits = 50
ghz = QuantumCircuit(num_qubits)
ghz.h(range(num_qubits))
ghz.cx(0, range(1, num_qubits))
op_counts = ghz.count_ops()

print("Pre-Transpilation: ")
print(f"CX gates: {op_counts['cx']}")
print(f"H gates: {op_counts['h']}")
print("\n", 30 * "#", "\n")

pm = generate_preset_pass_manager(optimization_level=3, backend=backend)
transpiled_ghz = pm.run(ghz)
op_counts = transpiled_ghz.count_ops()

print("Post-Transpilation: ")
print(f"CZ gates: {op_counts['cz']}")
print(f"ECR gates: {op_counts['ecr']}")
print(f"SX gates: {op_counts['sx']}")
print(f"RZ gates: {op_counts['rz']}")

Output:

Pre-Transpilation: 
CX gates: 49
H gates: 50

 ##############################

Post-Transpilation: 
CZ gates: 204
ECR gates: 8
SX gates: 374
RZ gates: 215

El circuito transpilado ahora contiene una mezcla de CZ puertas ECR y, que especificamos como puertas básicas en el backend Target. También hay bastantes más puertas que al principio debido a la necesidad de insertar instrucciones SWAP después de elegir un diseño. A continuación, se utiliza la herramienta plot_circuit_layout() de visualización para especificar qué qubits y canales de dos qubits se utilizaron en este circuito.

from qiskit.visualization import plot_circuit_layout

plot_circuit_layout(
    transpiled_ghz, backend, qubit_coordinates=total_qubit_coordinates
)

Output:

Crear backends únicos

El paquete rustworkx contiene una amplia biblioteca de gráficos diferentes y permite crear gráficos personalizados. El código visualmente interesante que se muestra a continuación crea un backend inspirado en el código tórico. A continuación, puede visualizar el backend utilizando las funciones de la sección Visualizar backends.

class FakeTorusBackend(BackendV2):
    """Fake multi chip backend."""

    def __init__(self):
        """Instantiate a new backend that is inspired by a toric code"""
        super().__init__(name="Fake LOCC backend")
        graph = rx.generators.directed_grid_graph(20, 20)
        for column in range(20):
            graph.add_edge(column, 19 * 20 + column, None)
        for row in range(20):
            graph.add_edge(row * 20, row * 20 + 19, None)
        num_qubits = len(graph)
        rng = np.random.default_rng(seed=12345678942)
        rz_props = {}
        x_props = {}
        sx_props = {}
        measure_props = {}
        delay_props = {}
        self._target = Target("Fake Kookaburra", num_qubits=num_qubits)
        # Add 1q gates. Globally use virtual rz, x, sx, and measure
        for i in range(num_qubits):
            qarg = (i,)
            rz_props[qarg] = InstructionProperties(error=0.0, duration=0.0)
            x_props[qarg] = InstructionProperties(
                error=rng.uniform(1e-6, 1e-4),
                duration=rng.uniform(1e-8, 9e-7),
            )
            sx_props[qarg] = InstructionProperties(
                error=rng.uniform(1e-6, 1e-4),
                duration=rng.uniform(1e-8, 9e-7),
            )
            measure_props[qarg] = InstructionProperties(
                error=rng.uniform(1e-3, 1e-1),
                duration=rng.uniform(1e-8, 9e-7),
            )
            delay_props[qarg] = None
        self._target.add_instruction(XGate(), x_props)
        self._target.add_instruction(SXGate(), sx_props)
        self._target.add_instruction(RZGate(Parameter("theta")), rz_props)
        self._target.add_instruction(Measure(), measure_props)
        self._target.add_instruction(Reset(), measure_props)
        self._target.add_instruction(Delay(Parameter("t")), delay_props)
        cz_props = {}
        for edge in graph.edge_list():
            cz_props[edge] = InstructionProperties(
                error=rng.uniform(7e-4, 5e-3),
                duration=rng.uniform(1e-8, 9e-7),
            )
        self._target.add_instruction(CZGate(), cz_props)

    @property
    def target(self):
        return self._target

    @property
    def max_circuits(self):
        return None

    @classmethod
    def _default_options(cls):
        return Options(shots=1024)

    def run(self, circuit, **kwargs):
        raise NotImplementedError("Lasciate ogne speranza, voi ch'intrate")

backend = FakeTorusBackend()
# We set `figsize` to a smaller size to make the documentation website faster
# to load. Normally, you do not need to set the argument.
plot_gate_map(backend, figsize=(4, 4))

Output:

num_qubits = int(backend.num_qubits / 2)
full_device_bv = QuantumCircuit(num_qubits, num_qubits - 1)
full_device_bv.x(num_qubits - 1)
full_device_bv.h(range(num_qubits))
full_device_bv.cx(range(num_qubits - 1), num_qubits - 1)
full_device_bv.h(range(num_qubits))
full_device_bv.measure(range(num_qubits - 1), range(num_qubits - 1))
tqc = transpile(full_device_bv, backend, optimization_level=3)
op_counts = tqc.count_ops()
print(f"CZ gates: {op_counts['cz']}")
print(f"X gates: {op_counts['x']}")
print(f"SX gates: {op_counts['sx']}")
print(f"RZ gates: {op_counts['rz']}")

Output:

CZ gates: 563
X gates: 6
SX gates: 1182
RZ gates: 1078

¿Le ha resultado útil esta página?

Informe de un error, de una errata o solicite contenido en GitHub.