Iskay Quantum Optimizer - O Funcție Qiskit de la Kipu Quantum

Vezi referința API

Notă

• Funcțiile Qiskit sunt o funcționalitate experimentală disponibilă doar utilizatorilor cu plan IBM Quantum® Premium, Flex și On-Prem (prin IBM Quantum Platform API). Acestea se află în stadiu de previzualizare și pot fi modificate.

Prezentare generală

Cu Iskay Quantum Optimizer de la Kipu Quantum, poți aborda probleme complexe de optimizare folosind calculatoarele® cuantice IBM. Acest solver folosește algoritmul de ultimă generație bf-DCQO al Kipu, necesitând doar funcția obiectiv ca intrare pentru a livra automat soluții la probleme. Poate gestiona probleme de optimizare cu până la 156 de qubiți, permițând utilizarea tuturor qubiților dispozitivelor cuantice IBM. Optimizer-ul folosește o mapare 1-la-1 între variabilele clasice și qubiți, ceea ce îți permite să abordezi probleme de optimizare cu până la 156 de variabile binare.

Optimizer-ul permite rezolvarea problemelor de optimizare binară neconstrânsă. Pe lângă formularea QUBO (Quadratic Unconstrained Binary Optimization) utilizată frecvent, acceptă și probleme de optimizare de ordin superior (HUBO). Solver-ul utilizează un algoritm cuantic non-variațional, efectuând cea mai mare parte a calculului pe dispozitive cuantice.

Cele ce urmează oferă mai multe detalii despre algoritmul utilizat și un ghid succint privind utilizarea funcției, precum și rezultatele testelor de performanță pe diverse instanțe de probleme de diferite dimensiuni și complexități.

Descriere

Optimizer-ul este o implementare gata de utilizare a unor algoritmi cuantici de optimizare de ultimă generație. Rezolvă probleme de optimizare rulând circuite cuantice puternic comprimate pe hardware cuantic. Această compresie este obținută prin introducerea termenilor contradiabatici în evoluția temporală a sistemului cuantic. Algoritmul execută mai multe iterații de rulări pe hardware pentru a obține soluțiile finale și le combină cu post-procesare. Acești pași sunt integrați fără probleme în fluxul de lucru al Optimizer-ului și sunt executați automat.

Cum funcționează Quantum Optimizer?

Această secțiune descrie principiile de bază ale algoritmului bf-DCQO implementat. O introducere în algoritm poate fi găsită și pe canalul YouTube Qiskit.

Algoritmul se bazează pe evoluția temporală a unui sistem cuantic care se transformă în timp, unde soluția problemei este codificată în starea de bază a sistemului cuantic la sfârșitul evoluției. Conform teoremei adiabatice, această evoluție trebuie să fie lentă pentru a garanta că sistemul rămâne în starea sa de bază. Digitizarea acestei evoluții stă la baza calculului cuantic adiabatic digitizat (DQA) și a infamului algoritm QAOA. Cu toate acestea, evoluția lentă necesară nu este fezabilă pentru dimensiuni crescânde ale problemei, deoarece duce la o adâncime crescândă a Circuit-ului. Prin utilizarea protocoalelor contradiabatice, poți suprima excitațiile nedorite care apar în timpul evoluțiilor scurte, rămânând totodată în starea de bază. Digitizarea acestui timp de evoluție mai scurt duce la circuit-uri cuantice cu adâncime mai mică și mai puține Gate-uri de entanglare.

Circuit-urile algoritmilor bf-DCQO utilizează în mod tipic de până la zece ori mai puține Gate-uri de entanglare decât DQA și de trei până la patru ori mai puține Gate-uri de entanglare decât implementările standard QAOA. Datorită numărului mai mic de poartă-uri, apar mai puține erori în timpul execuției Circuit-ului pe hardware. Prin urmare, Optimizer-ul nu necesită utilizarea tehnicilor de suprimare sau de atenuare a erorilor. Implementarea lor în versiunile viitoare poate îmbunătăți și mai mult calitatea soluției.

Deși algoritmul bf-DCQO utilizează iterații, acesta este non-variațional. După fiecare iterație a algoritmului, distribuția stărilor este măsurată. Distribuția obținută este utilizată pentru a calcula un așa-numit câmp de polarizare (bias-field). Câmpul de polarizare permite inițierea următoarei iterații dintr-o stare energetică apropiată de soluția găsită anterior. În acest fel, algoritmul se deplasează cu fiecare iterație spre soluții de energie mai mică. De obicei, aproximativ zece iterații sunt suficiente pentru a converge la o soluție, necesitând în total un număr mult mai mic de iterații decât algoritmii variaționali, care este de ordinul a aproximativ 100 de iterații.

Optimizer-ul combină algoritmul bf-DCQO cu post-procesare clasică. După măsurarea distribuției stărilor, se efectuează o căutare locală. În timpul căutării locale, biții soluției măsurate sunt inversați aleatoriu. După inversare, energia noului șir de biți este evaluată. Dacă energia este mai mică, șirul de biți este păstrat ca noua soluție. Căutarea locală scalează liniar cu numărul de qubiți; prin urmare, este eficientă din punct de vedere computațional. Deoarece post-procesarea corectează inversările locale de biți, compensează erorile de inversare a biților care sunt adesea rezultatul imperfecțiunilor hardware și al erorilor de citire.

Flux de lucru

Urmează o schemă a fluxului de lucru al Quantum Optimizer.

Prin utilizarea Quantum Optimizer, rezolvarea unei probleme de optimizare pe hardware cuantic poate fi redusă la

• Formularea funcției obiectiv a problemei
• Accesarea Optimizer-ului prin Qiskit Functions
• Rularea Optimizer-ului și colectarea rezultatului

Benchmarks

Metricile de benchmark de mai jos arată că Optimizer-ul abordează eficient problemele cu până la 156 de qubiți și oferă o privire de ansamblu generală asupra acurateței și scalabilității Optimizer-ului pentru diferite tipuri de probleme. Reține că metricile reale de performanță pot varia în funcție de caracteristicile specifice ale problemei, cum ar fi numărul de variabile, densitatea și localitatea termenilor din funcția obiectiv și ordinul polinomial.

Tabelul următor include raportul de aproximare (AR), o metrică definită astfel:

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

unde $C$ este funcția obiectiv, $C_{\textrm{min}}$, $C_{\textrm{max}}$ sunt valorile sale minime și maxime, iar $C^{*}$ este costul celei mai bune soluții găsite, respectiv. Prin urmare, AR=100% înseamnă că s-a obținut starea de bază a problemei.

Exemplu	Număr de qubiți	Raport de aproximare	Timp total (s)	Utilizare runtime (s)	Număr total de shots	Număr de iterații
Unweighted MaxCut	28	100%	180	30	30k	5
Unweighted MaxCut	30	100%	180	30	30k	5
Unweighted MaxCut	32	100%	180	30	30k	5
Unweighted MaxCut	80	100%	480	60	90k	9
Unweighted MaxCut	100	100%	330	60	60k	6
Unweighted MaxCut	120	100%	370	60	60k	6
HUBO 1	156	100%	600	70	100k	10
HUBO 2	156	100%	600	70	100k	10

• Instanțele MaxCut cu 28, 30 și 32 de qubiți au rulat pe ibm_sherbrooke. Instanțele cu 80, 100 și 120 au rulat pe un procesor Heron r2.
• Instanțele HUBO au rulat de asemenea pe un procesor Heron r2.

Toate instanțele de benchmark sunt accesibile pe GitHub (vezi instanțe benchmark Kipu). Un exemplu pentru rularea acestor instanțe poate fi găsit în Exemplul 3: Instanțe benchmark.

Începe

În această documentație, vom parcurge pașii pentru a utiliza Iskay Quantum Optimizer. În acest proces, vom arăta rapid cum să încarci funcția din catalog și cum să convertești problema ta într-un input valid, demonstrând totodată cum poți experimenta cu diferiți parametri opționali.

Pentru un exemplu mai detaliat, consultă tutorialul Rezolvă problema Market Split cu Iskay Quantum Optimizer de la Kipu Quantum, unde parcurgem întregul proces de utilizare a Iskay Solver pentru a aborda problema Market Split, care reprezintă o provocare reală de alocare a resurselor în care piețele trebuie împărțite în regiuni de vânzare echilibrate pentru a satisface ținte exacte de cerere.

Autentifică-te folosind cheia ta API, disponibilă pe panoul de bord IBM Quantum Platform, și selectează Qiskit Function după cum urmează:

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

# ruff: noqa: F821

notă

Codul următor presupune că ți-ai salvat acreditările. Dacă nu ai făcut acest lucru, urmează instrucțiunile din salvează contul tău IBM Cloud pentru a te autentifica cu cheia ta API.

from qiskit_ibm_catalog import QiskitFunctionsCatalog

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

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

Exemplu de configurare personalizată

Iată cum ai putea configura Iskay cu setări diferite:

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,  # Use higher transpilation level to optimize circuit
    "seed_transpiler": 42,  # Fixed seed for reproducible results
    "job_tags": ["custom_config"],  # Custom tracking tags
}

Example 1: Funcție de cost simplă

Consideră funcția de cost în formulare 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$$

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

Soluția acestei funcții de cost simple este

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

cu valoarea minimă $C^{*} = -6$

1. Creează funcția obiectiv

Începem prin a crea un dicționar cu coeficienții funcției obiectiv, după cum urmează:

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

2. Rulează Optimizer-ul

Rezolvăm problema rulând Optimizer-ul. Deoarece $(x_0, ..., x_4) \in \{-1, 1\}^5$, trebuie să setăm 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. Recuperează rezultatul

Soluția problemei de optimizare este furnizată direct de către Optimizer.

print(job.result())

Aceasta va afișa un dicționar de 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'}

Observă că dicționarul solution afișează vectorul rezultat $(x_0, x_1, x_2, x_3, x_4) = (-1, -1, -1, 1, 1)$.

Exemplul 2: MaxCut

Multe probleme de grafuri, precum MaxCut sau mulțimea independentă maximă, sunt probleme NP-dificile și candidați ideali pentru testarea algoritmilor și hardware-ului cuantic. Acest exemplu demonstrează rezolvarea problemei MaxCut pe un graf 3-regulat cu ajutorul Quantum Optimizer.

Pentru a rula acest exemplu, trebuie să instalezi pachetul networkx în plus față de qiskit-ibm-catalog. Pentru a-l instala, rulează următoarea comandă:

# %pip install networkx numpy

1. Creează funcția obiectiv

Începe prin generarea unui graf aleatoriu 3-regulat. Pentru acest graf, definim funcția obiectiv a problemei 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. Rulează Optimizer-ul

Rezolvă problema rulând Optimizer-ul.

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. Obține rezultatul

Obține rezultatul și mapează șirul de biți al soluției înapoi la nodurile grafului original.

print(job.result())

Soluția problemei Maxcut este conținută direct în sub-dicționarul solution al obiectului rezultat

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

Exemplul 3: Instanțe de referință

Instanțele de referință sunt disponibile pe GitHub: Kipu benchmark instances.

Instanțele pot fi încărcate folosind biblioteca pygithub. Pentru a o instala, rulează următoarea comandă:

# %pip install pygithub

Căile pentru instanțele de referință sunt:

Maxcut:

• 'maxcut/maxcut_regular_3_100_nodes_weighted.json'
• 'maxcut/maxcut_regular_3_140_nodes_weighted.json'
• 'maxcut/maxcut_regular_3_150_nodes_weighted.json'
• 'maxcut/maxcut_regular_4_130_nodes_weighted.json'

HUBO:

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

Pentru a reproduce performanța de referință pentru instanțele HUBO, selectează Backend-ul ibm_marrakesh și setează direct_qubit_mapping la True în sub-dicționarul options. Următorul exemplu rulează instanța Maxcut cu 150 de noduri.

from github import Github
import urllib
import json
import ast

repo = "Kipu-Quantum-GmbH/benchmark-instances"
path = "maxcut/maxcut_regular_3_150_nodes_weighted.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": "<BACKEND-NAME>",
    "options": options,
}

job = optimizer.run(**arguments)

result = job.result()

Cazuri de utilizare

Cazurile de utilizare tipice pentru solverul de optimizare sunt problemele de optimizare combinatorie. Poți rezolva probleme din multe industrii, precum finanțe, farmacie sau logistică. Câteva exemple urmează.

• Optimizarea portofoliului (QUBO): publicație științifică și white paper
• Plierea proteinelor (HUBO): publicație științifică
• Planificarea logistică (QUBO): publicație științifică
• Optimizarea rețelelor: webinar
• Împărțirea pieței (QUBO): tutorial

Dacă ești interesat să abordezi un caz de utilizare specific și să dezvolți o mapare dedicată, te putem ajuta. Contactează-ne.

Obține suport

Pentru suport, contactează support@kipu-quantum.com.

Pași următori

• Solicită acces la Quantum Optimizer de la Kipu Quantum.
• Vizitează referința API pentru această Funcție Qiskit.
• Încearcă tutorialul Rezolvă problema Market Split cu Iskay Quantum Optimizer de la Kipu Quantum.
• Consultă Romero, S. V., et al. (2025). Bias-Field Digitized Counterdiabatic Quantum Algorithm for Higher-Order Binary Optimization. arXiv preprint arXiv:2409.04477.
• Consultă Cadavid, A. G., et al. (2024). Bias-field digitized counterdiabatic quantum optimization. arXiv preprint arXiv:2405.13898.
• Consultă Chandarana, P., et al. (2025). Runtime Quantum Advantage with Digital Quantum Optimization. arXiv preprint arXiv:2505.08663.

Informații suplimentare

Iskay, la fel ca numele companiei noastre Kipu Quantum, este un cuvânt peruan. Deși suntem un startup din Germania, aceste cuvinte provin din țara natală a unuia dintre co-fondatorii noștri, unde Quipu a fost una dintre primele mașini de calcul dezvoltate de umanitate cu 2000 de ani î.Hr.