Saltar a contenido

Qiskit loader#

Introducción#

El Qiskit loader permite que un solver acceda al backend de IBM Quantum seleccionado para un job de QCentroid sin hardcodear credenciales de IBM ni nombres de backend en el código fuente.

Usa este loader cuando tu solver construya circuitos con Qiskit y los envíe con qiskit-ibm-runtime.

Import#

from QCentroidLoaders import QiskitLoader

Obtener el backend seleccionado#

Llama a QiskitLoader.get_target() cuando tu solver esté listo para enviar el circuito:

backend = QiskitLoader.get_target()

En el runtime de la plataforma, este backend se resuelve a partir del proveedor y backend seleccionados por el usuario al lanzar el job.

Cuando se ejecuta localmente sin inicialización de la plataforma, QiskitLoader.get_target() devuelve un simulador local de Qiskit. Usa qiskit_aer.AerSimulator cuando qiskit-aer está instalado, y hace fallback a qiskit.providers.basic_provider.BasicSimulator en caso contrario.

Solver de ejemplo#

qcentroid.py
from typing import Any
import logging

from qiskit import QuantumCircuit
from qiskit.transpiler import generate_preset_pass_manager
from qiskit_ibm_runtime import SamplerV2
from QCentroidLoaders import QiskitLoader

logger = logging.getLogger("qcentroid-user-log")
logging.basicConfig()
logger.setLevel(logging.INFO)

def run(
    input_data: dict[str, Any],
    solver_params: dict[str, Any],
    extra_arguments: dict[str, Any],
) -> dict[str, Any]:
    logger.info("Creating circuit...")

    qc = QuantumCircuit(1, 1)
    qc.x(0)
    qc.measure_all()

    backend = QiskitLoader.get_target()
    logger.info(f"Using backend: {backend}")

    optimization_level = solver_params.get("optimization_level", 1)
    shots = solver_params.get("shots", 1024)

    pm = generate_preset_pass_manager(
        optimization_level=optimization_level,
        backend=backend,
    )
    isa_circuit = pm.run(qc)

    sampler = SamplerV2(backend)

    logger.info("Sending job to IBM Quantum...")
    job = sampler.run([isa_circuit], shots=shots)

    logger.info("Obtaining job result...")
    result = job.result()[0]
    counts = result.data.meas.get_counts()

    logger.info(f"Result from backend: {counts}")

    return {
        "status": "ok",
        "provider": "qiskit",
        "backend": str(backend),
        "result": counts,
    }

Ejecución en la plataforma#

Cuando este solver se ejecuta en QCentroid:

  1. El usuario selecciona el solver y el backend de IBM Quantum en el dashboard o la API.
  2. La plataforma inyecta el access token del proveedor en el entorno de runtime.
  3. QiskitLoader.get_target() devuelve el backend configurado.
  4. El solver envía el circuito y devuelve el resultado a QCentroid.

Ejecución local#

Para desarrollo local, instala el paquete local de loaders desde el repositorio público de QCentroid Loaders cuando esté disponible:

pip install git+<loaders-repository-url>

Después configura tus credenciales de IBM Quantum como se describe en ese repositorio si quieres ejecutar localmente contra un backend remoto de IBM Quantum. Si no inicializas el loader con un backend remoto, el loader devuelve un simulador local.

Buenas prácticas#

  • Mantén shots y las opciones de transpilación configurables mediante solver_params cuando los usuarios necesiten controlar coste o precisión.
  • Registra en logs el nombre del backend y la fase de envío, pero nunca registres access tokens.
  • Valida circuitos localmente o en un simulador antes de ejecutarlos en hardware de pago.

Páginas relacionadas#

Vista general de QCentroid Loaders

Buenas prácticas de control de costes de IBM Quantum