Iskay Quantum Optimizer - Una función de Qiskit por Kipu Quantum

Consulta la referencia de la API

Nota

• Las funciones de Qiskit son una característica experimental disponible únicamente para los usuarios de los planes IBM Quantum® Premium, Flex y On-Prem (a través de la API de IBM Quantum Platform). Se encuentran en estado de versión preliminar y están sujetas a cambios.

Descripción general

Con el Iskay Quantum Optimizer de Kipu Quantum, puedes abordar problemas de optimización complejos utilizando los computadores cuánticos de IBM®. Este solver aprovecha el algoritmo bf-DCQO de vanguardia de Kipu, que requiere únicamente la función objetivo como entrada para entregar automáticamente las soluciones a los problemas. Puede gestionar problemas de optimización que involucran hasta 156 qubits, lo que permite utilizar todos los qubits de los dispositivos cuánticos de IBM. El Optimizer emplea un mapeo 1 a 1 entre variables clásicas y qubits, lo que te permite abordar problemas de optimización con hasta 156 variables binarias.

El Optimizer permite resolver problemas de optimización binaria sin restricciones. Además de la formulación QUBO (Quadratic Unconstrained Binary Optimization) de uso común, también admite problemas de optimización de orden superior (HUBO). El solver utiliza un algoritmo cuántico no variacional, realizando la mayor parte del cómputo en dispositivos cuánticos.

A continuación se presentan más detalles sobre el algoritmo utilizado y una guía breve sobre cómo usar la función, así como resultados de benchmarking en diversas instancias de problemas de diferentes tamaños y complejidades.

Descripción

El Optimizer es una implementación lista para usar de algoritmos de optimización cuántica de vanguardia. Resuelve problemas de optimización ejecutando circuitos cuánticos altamente comprimidos en hardware cuántico. Esta compresión se logra introduciendo términos contradiabáticos en la evolución temporal subyacente del sistema cuántico. El algoritmo ejecuta varias iteraciones de ejecuciones en hardware para obtener las soluciones finales y las combina con posprocesamiento. Estos pasos están integrados de forma transparente en el flujo de trabajo del Optimizer y se ejecutan automáticamente.

¿Cómo funciona el Quantum Optimizer?

Esta sección describe los fundamentos del algoritmo bf-DCQO implementado. También se puede encontrar una introducción al algoritmo en el canal de YouTube de Qiskit.

El algoritmo se basa en la evolución temporal de un sistema cuántico que se transforma con el tiempo, donde la solución al problema está codificada en el estado fundamental del sistema cuántico al final de la evolución. Según el teorema adiabático, esta evolución debe ser lenta para garantizar que el sistema permanezca en su estado fundamental. Digitalizar esta evolución es la base del cómputo adiabático cuántico digitalizado (DQA) y del conocido algoritmo QAOA. Sin embargo, la evolución lenta requerida no es factible a medida que aumenta el tamaño del problema, ya que resulta en una profundidad de circuito creciente. Al usar protocolos contradiabáticos, es posible suprimir las excitaciones no deseadas que ocurren durante tiempos de evolución cortos, permaneciendo en el estado fundamental. En este caso, digitalizar este tiempo de evolución más corto produce circuitos cuánticos de menor profundidad y con menos puertas de entrelazamiento.

Los circuitos de los algoritmos bf-DCQO típicamente usan hasta diez veces menos puertas de entrelazamiento que DQA, y de tres a cuatro veces menos puertas de entrelazamiento que las implementaciones estándar de QAOA. Gracias al menor número de puertas, ocurren menos errores durante la ejecución del circuito en hardware. Por tanto, el optimizer no requiere el uso de técnicas como supresión de errores o mitigación de errores. Implementarlas en versiones futuras puede mejorar aún más la calidad de las soluciones.

Aunque el algoritmo bf-DCQO usa iteraciones, es no variacional. Después de cada iteración del algoritmo, se mide la distribución de estados. La distribución obtenida se usa para calcular un llamado campo de sesgo (bias-field). El campo de sesgo permite comenzar la siguiente iteración desde un estado de energía cercano a la solución encontrada anteriormente. De esta manera, el algoritmo avanza con cada iteración hacia soluciones de menor energía. Típicamente, aproximadamente diez iteraciones son suficientes para converger a una solución, requiriendo en total un número de iteraciones mucho menor que los algoritmos variacionales, que es del orden de aproximadamente 100 iteraciones.

El optimizer combina el algoritmo bf-DCQO con posprocesamiento clásico. Después de medir la distribución de estados, se realiza una búsqueda local. Durante la búsqueda local, los bits de la solución medida se invierten aleatoriamente. Después de la inversión, se evalúa la energía del nuevo bitstring. Si la energía es menor, el bitstring se conserva como la nueva solución. La búsqueda local solo escala linealmente con el número de qubits; por lo tanto, es computacionalmente económica. Dado que el posprocesamiento corrige inversiones de bits locales, compensa los errores de inversión de bits que a menudo son el resultado de imperfecciones del hardware y errores de lectura.

Flujo de trabajo

A continuación se muestra un esquema del flujo de trabajo del Quantum Optimizer.

Al utilizar el Quantum Optimizer, resolver un problema de optimización en hardware cuántico se puede reducir a:

• Formular la función objetivo del problema
• Acceder al Optimizer a través de las funciones de Qiskit
• Ejecutar el Optimizer y recopilar el resultado

Benchmarks

Las métricas de benchmark a continuación muestran que el Optimizer aborda eficazmente problemas de hasta 156 qubits y ofrecen una visión general de la precisión y escalabilidad del optimizer en diferentes tipos de problemas. Ten en cuenta que las métricas de rendimiento reales pueden variar según las características específicas del problema, como el número de variables, la densidad y localidad de los términos en la función objetivo, y el orden polinomial.

La siguiente tabla incluye la razón de aproximación (AR), una métrica definida de la siguiente manera:

$$AR = \frac{C^{*} - C_\textrm{max}}{C_{\textrm{min}} - C_{\textrm{max}}},$$

donde $C$ es la función objetivo, $C_{\textrm{min}}$, $C_{\textrm{max}}$ son sus valores mínimo y máximo, y $C^{*}$ es el costo de la mejor solución encontrada, respectivamente. Por lo tanto, AR=100% significa que se ha obtenido el estado fundamental del problema.

Ejemplo	Número de qubits	Razón de aproximación	Tiempo total (s)	Uso de runtime (s)	Número total de shots	Número de iteraciones
MaxCut no ponderado	28	100%	180	30	30k	5
MaxCut no ponderado	30	100%	180	30	30k	5
MaxCut no ponderado	32	100%	180	30	30k	5
MaxCut no ponderado	80	100%	480	60	90k	9
MaxCut no ponderado	100	100%	330	60	60k	6
MaxCut no ponderado	120	100%	370	60	60k	6
HUBO 1	156	100%	600	70	100k	10
HUBO 2	156	100%	600	70	100k	10

• Las instancias de MaxCut con 28, 30 y 32 qubits se ejecutaron en ibm_sherbrooke. Las instancias con 80, 100 y 120 se ejecutaron en un procesador Heron r2.
• Las instancias HUBO también se ejecutaron en un procesador Heron r2.

Todas las instancias de benchmark están disponibles en GitHub (ver instancias de benchmark de Kipu). Un ejemplo para ejecutar estas instancias se puede encontrar en Ejemplo 3: Instancias de benchmark.

Primeros pasos

En esta documentación, repasaremos los pasos para usar el Iskay Quantum Optimizer. En el proceso, mostraremos rápidamente cómo cargar la función desde el catálogo y cómo convertir tu problema a una entrada válida, mostrando al mismo tiempo cómo puedes experimentar con diferentes parámetros opcionales.

Para un ejemplo más detallado, consulta el tutorial Resuelve el problema Market Split con el Iskay Quantum Optimizer de Kipu Quantum, donde trabajamos todo el proceso de usar Iskay Solver para abordar el problema Market Split, que representa un desafío de asignación de recursos del mundo real donde los mercados deben particionarse en regiones de ventas equilibradas para cumplir con objetivos de demanda exactos.

Autentícate con tu clave de API, que puedes encontrar en el panel de control de IBM Quantum Platform, y selecciona la función de Qiskit de la siguiente manera:

# Added by doQumentation — required packages for this notebook
!pip install -q PyGithub networkx qiskit-ibm-catalog

# ruff: noqa: F821

nota

El siguiente código asume que has guardado tus credenciales. Si no lo has hecho, sigue las instrucciones en guardar tu cuenta de IBM Cloud para autenticarte con tu clave de API.

from qiskit_ibm_catalog import QiskitFunctionsCatalog

catalog = QiskitFunctionsCatalog(
    channel="ibm_quantum_platform",
    instance="INSTANCE_CRN",
    token="YOUR_API_KEY",  # Use the 44-character API_KEY you created and saved from the IBM Quantum Platform Home dashboard
)

# Access Function
optimizer = catalog.load("kipu-quantum/iskay-quantum-optimizer")

Ejemplo de configuración personalizada

Así es como podrías configurar Iskay con diferentes ajustes:

custom_options = {
    "shots": 15_000,  # Higher shot count for better statistics
    "num_iterations": 12,  # More iterations for solution refinement
    "preprocessing_level": 1,  # Light preprocessing for problem simplification
    "postprocessing_level": 2,  # Maximum postprocessing for solution quality
    "transpilation_level": 3,  # Using higher transpilation level for circuit optimization
    "seed_transpiler": 42,  # Fixed seed for reproducible results
    "job_tags": ["custom_config"],  # Custom tracking tags
}

Optimización de la semilla: Ten en cuenta que seed_transpiler se establece en None de forma predeterminada. Esto activa el proceso de optimización automática del transpilador. Cuando es None, el sistema iniciará una prueba con múltiples semillas y seleccionará la que produzca la menor profundidad de circuito, aprovechando al máximo el parámetro max_trials para cada nivel de transpilación.

Rendimiento del nivel de transpilación: Aumentar el número de max_trials con valores más altos para transpilation_level inevitablemente incrementará el tiempo de transpilación, pero puede que no siempre cambie el circuito final; esto depende en gran medida de la estructura y complejidad específicas del circuito. Sin embargo, para algunos circuitos/problemas, la diferencia entre 10 intentos (nivel 1) y 50 intentos (nivel 5) puede ser considerable, por lo que explorar estos parámetros puede ser clave para encontrar una solución con éxito.

Ejemplo 1: Función de costo simple

Considera la función de costo en formulación spin:

$$C(x_0, x_1, x_2, x_3, x_4) = 1 + 1.5x_0 + 2x_1 + 1.3x_2 + 2.5x_0x_3 + 3.5x_1x_4 + 4x_0x_1x_2$$

donde $(x_0, ..., x_4) \in \{-1, 1\}^5$.

La solución a esta función de costo simple es

$$(x_0, x_1, x_2, x_3, x_4) = (-1, -1, -1, 1, 1)$$

con valor mínimo $C^{*} = -6$

1. Crear la función objetivo

Comenzamos creando un diccionario con los coeficientes de la función objetivo de la siguiente manera:

objective_func = {
    "()": 1,
    "(0,)": 1.5,
    "(1,)": 2,
    "(2,)": 1.3,
    "(0, 3)": 2.5,
    "(1, 4)": 3.5,
    "(0, 1, 2)": 4,
}

2. Ejecutar el Optimizer

Resolvemos el problema ejecutando el optimizer. Dado que $(x_0, ..., x_4) \in \{-1, 1\}^5$, debemos establecer problem_type=spin.

# Setup options to run the optimizer
options = {"shots": 5000, "num_iterations": 5, "use_session": True}

arguments = {
    "problem": objective_func,
    "problem_type": "spin",
    "backend_name": backend_name,  # such as "ibm_fez"
    "options": options,
}

job = optimizer.run(**arguments)

3. Obtener el resultado

La solución del problema de optimización se obtiene directamente desde el optimizer.

print(job.result())

Esto mostrará un diccionario de la forma:

{'solution': {'0': -1, '1': -1, '2': -1, '3': 1, '4': 1},
 'solution_info': {'bitstring': '11100',
  'cost': -13.8,
  'seed_transpiler': 42,
  'mapping': {0: 0, 1: 1, 2: 2, 3: 3, 4: 4}},
 'prob_type': 'spin'}

Observa que el diccionario solution muestra el vector resultado $(x_0, x_1, x_2, x_3, x_4) = (-1, -1, -1, 1, 1)$.

Ejemplo 2: MaxCut

Muchos problemas de grafos como MaxCut o el conjunto independiente máximo son problemas NP-difíciles e ideales para probar algoritmos cuánticos y hardware. Este ejemplo demuestra cómo resolver el problema MaxCut de un grafo 3-regular con el Quantum Optimizer.

Para ejecutar este ejemplo debes instalar el paquete networkx además de qiskit-ibm-catalog. Para instalarlo, ejecuta el siguiente comando:

# %pip install networkx numpy

1. Crear la función objetivo

Comienza generando un grafo 3-regular aleatorio. Para este grafo, definimos la función objetivo del problema MaxCut.

import networkx as nx

# Create a random 3-regular graph
G = nx.random_regular_graph(3, 10, seed=42)

# Create the objective function for MaxCut in Ising formulation
def graph_to_ising_maxcut(G):
    """
    Convert a NetworkX graph to an Ising Hamiltonian for the max-cut problem.
    Args:
        G (networkx.Graph): The input graph.
    Returns:
        dict: The objective function of the Ising model
    """
    # Initialize the linear and quadratic coefficients
    objective_func = {}
    # Populate the coefficients
    for i, j in G.edges:
        objective_func[f"({i}, {j})"] = 0.5
    return objective_func

objective_func = graph_to_ising_maxcut(G)

2. Ejecutar el Optimizer

Resuelve el problema ejecutando el optimizer.

options = {"shots": 5000, "num_iterations": 5, "use_session": True}

arguments = {
    "problem": objective_func,
    "problem_type": "spin",
    "backend_name": backend_name,  # such as "ibm_fez"
    "options": options,
}

job = optimizer.run(**arguments)

3. Obtener el resultado

Recupera el resultado y mapea el bitstring de solución de vuelta a los nodos originales del grafo.

print(job.result())

La solución al problema Maxcut está contenida directamente en el sub-diccionario solution del objeto resultado

maxcut_solution = job.result()["solution"]

Ejemplo 3: Instancias de benchmark

Las instancias de benchmark están disponibles en GitHub: Instancias de benchmark de Kipu.

Las instancias se pueden cargar usando la biblioteca pygithub. Para instalarla, ejecuta el siguiente comando:

# %pip install pygithub

Las rutas para las instancias de benchmark son:

Maxcut:

• 'maxcut/maxcut_28_nodes.json'
• 'maxcut/maxcut_30_nodes.json'
• 'maxcut/maxcut_32_nodes.json'
• 'maxcut/maxcut_80_nodes.json'
• 'maxcut/maxcut_100_nodes.json'
• 'maxcut/maxcut_120_nodes.json'

HUBO:

• 'HUBO/hubo1_marrakesh.json'
• 'HUBO/hubo2_marrakesh.json'

Para reproducir el rendimiento del benchmark para las instancias HUBO, selecciona el backend ibm_marrakesh y establece direct_qubit_mapping en True en el sub-diccionario options. El siguiente ejemplo ejecuta la instancia Maxcut con 32 nodos.

from github import Github
import urllib
import json
import ast

repo = "Kipu-Quantum-GmbH/benchmark-instances"
path = "maxcut/maxcut_32_nodes.json"
gh = Github()
repo = gh.get_repo(repo)
branch = "main"
file = repo.get_contents(urllib.parse.quote(path), ref=branch)

# load json file with benchmark problem
problem_json = json.loads(file.decoded_content)

# convert objective function to compatible format
objective_func = {
    key: ast.literal_eval(value) for key, value in problem_json.items()
}

# Setup configuration to run the optimizer
options = {
    "shots": 5_000,
    "num_iterations": 5,
    "use_session": True,
    "direct_qubit_mapping": False,
}

arguments = {
    "problem": objective_func,
    "problem_type": "spin",
    "backend_name": "ibm_brisbane",
    "options": options,
}

job = optimizer.run(**arguments)

result = job.result()

Casos de uso

Los casos de uso típicos para el solver de optimización son problemas de optimización combinatoria. Puedes resolver problemas de muchas industrias como finanzas, farmacéutica o logística. A continuación se presentan algunos ejemplos.

• Optimización de cartera (QUBO): publicación científica y libro blanco
• Plegamiento de proteínas (HUBO): publicación científica
• Programación logística (QUBO): publicación científica
• Optimización de redes: webinar
• Market split (QUBO): tutorial

Si estás interesado en abordar un caso de uso específico y desarrollar un mapeo dedicado, podemos ayudarte. Contáctanos.

Obtener soporte

Para soporte, contacta a support@kipu-quantum.com.

Próximos pasos

• Solicitar acceso al Quantum Optimizer de Kipu Quantum.
• Visita la referencia de la API para esta función de Qiskit.
• Prueba el tutorial Resuelve el problema Market Split con el Iskay Quantum Optimizer de Kipu Quantum.
• Consulta Romero, S. V., et al. (2025). Bias-Field Digitized Counterdiabatic Quantum Algorithm for Higher-Order Binary Optimization. arXiv preprint arXiv:2409.04477.
• Consulta Cadavid, A. G., et al. (2024). Bias-field digitized counterdiabatic quantum optimization. arXiv preprint arXiv:2405.13898.
• Consulta Chandarana, P., et al. (2025). Runtime Quantum Advantage with Digital Quantum Optimization. arXiv preprint arXiv:2505.08663.

Información adicional

Iskay, al igual que el nombre de nuestra empresa Kipu Quantum, es una palabra peruana. Aunque somos una startup de Alemania, estas palabras provienen del país natal de uno de nuestros cofundadores, donde el Quipu fue una de las primeras máquinas de cálculo desarrolladas por la humanidad hace 2000 años a.C.