Iskay Quantum Optimizer – funkcja Qiskit od Kipu Quantum

Uwaga

Funkcje Qiskit to funkcja eksperymentalna dostępna wyłącznie dla użytkowników planów IBM Quantum® Premium Plan, Flex Plan i On-Prem (przez IBM Quantum Platform API). Mają one status wersji przedpremierowej i mogą ulec zmianie.

Przegląd

Dzięki Iskay Quantum Optimizer od Kipu Quantum możesz rozwiązywać złożone problemy optymalizacyjne przy użyciu komputerów kwantowych IBM®. Ten solver wykorzystuje najnowocześniejszy algorytm bf-DCQO firmy Kipu, który wymaga jedynie funkcji celu jako danych wejściowych, aby automatycznie dostarczać rozwiązania problemów. Radzi sobie z problemami optymalizacyjnymi obejmującymi do 156 Qubitów, umożliwiając wykorzystanie wszystkich Qubitów urządzeń kwantowych IBM. Optimizer stosuje odwzorowanie 1-do-1 między zmiennymi klasycznymi a Qubitami, co pozwala rozwiązywać problemy optymalizacyjne z maksymalnie 156 zmiennymi binarnymi.

Optimizer umożliwia rozwiązywanie binarnych problemów optymalizacyjnych bez ograniczeń. Oprócz powszechnie stosowanej formulacji QUBO (Quadratic Unconstrained Binary Optimization) obsługuje również problemy optymalizacyjne wyższego rzędu (HUBO). Solver wykorzystuje niewariacyjny algorytm kwantowy, wykonując większość obliczeń na urządzeniach kwantowych.

Poniżej znajdziesz więcej szczegółów na temat zastosowanego algorytmu oraz krótki przewodnik po sposobie korzystania z funkcji, a także wyniki testów porównawczych dla różnych instancji problemów o różnych rozmiarach i złożonościach.

Opis

Optimizer to gotowa do użycia implementacja najnowocześniejszych algorytmów optymalizacji kwantowej. Rozwiązuje problemy optymalizacyjne, uruchamiając wysoce skompresowane Circuit na sprzęcie kwantowym. Kompresja ta jest osiągana poprzez wprowadzenie terminów kontradiabatycznych do bazowej ewolucji czasowej układu kwantowego. Algorytm wykonuje kilka iteracji uruchomień sprzętowych, aby uzyskać końcowe rozwiązania, i łączy je z przetwarzaniem końcowym. Kroki te są płynnie zintegrowane z przepływem pracy Optimizera i wykonywane automatycznie.

Jak działa Quantum Optimizer?

Ta sekcja przedstawia podstawy zaimplementowanego algorytmu bf-DCQO. Wprowadzenie do algorytmu można również znaleźć na kanale YouTube Qiskit.

Algorytm opiera się na ewolucji czasowej układu kwantowego, który zmienia się w czasie, przy czym rozwiązanie problemu jest zakodowane w stanie podstawowym układu kwantowego na końcu ewolucji. Zgodnie z twierdzeniem adiabatycznym, ta ewolucja musi przebiegać powoli, aby układ pozostawał w swoim stanie podstawowym. Digitalizacja tej ewolucji stanowi podstawę cyfrowego kwantowego obliczania adiabatycznego (DQA) i niesławnego algorytmu QAOA. Jednak wymagana powolna ewolucja nie jest wykonalna dla coraz większych rozmiarów problemów, ponieważ skutkuje rosnącą głębokością Circuit. Stosując protokoły kontradiabatyczne, możesz tłumić niechciane wzbudzenia pojawiające się w krótkich czasach ewolucji, pozostając jednocześnie w stanie podstawowym. Tutaj digitalizacja tego krótszego czasu ewolucji skutkuje Circuit o mniejszej głębokości i mniejszej liczbie bramek splątujących.

Circuit algorytmów bf-DCQO zazwyczaj wykorzystują do dziesięciu razy mniej bramek splątujących niż DQA oraz od trzech do czterech razy mniej bramek splątujących niż standardowe implementacje QAOA. Ze względu na mniejszą liczbę Gate, podczas wykonywania Circuit na sprzęcie pojawia się mniej błędów. Dlatego optimizer nie wymaga stosowania technik takich jak tłumienie błędów czy łagodzenie błędów. Ich implementacja w przyszłych wersjach może jeszcze bardziej poprawić jakość rozwiązań.

Choć algorytm bf-DCQO korzysta z iteracji, jest niewariacyjny. Po każdej iteracji algorytmu mierzona jest dystrybucja stanów. Uzyskana dystrybucja służy do obliczenia tzw. pola biasu. Pole biasu umożliwia rozpoczęcie następnej iteracji ze stanu energetycznego bliskiego poprzednio znalezionemu rozwiązaniu. W ten sposób algorytm z każdą iteracją przesuwa się ku rozwiązaniom o niższej energii. Zazwyczaj około dziesięciu iteracji wystarczy, aby zbiec do rozwiązania, co łącznie wymaga znacznie mniejszej liczby iteracji niż algorytmy wariacyjne, gdzie wynosi ona rzędu około 100 iteracji.

Optimizer łączy algorytm bf-DCQO z klasycznym przetwarzaniem końcowym. Po zmierzeniu dystrybucji stanów wykonywane jest lokalne przeszukiwanie. W trakcie lokalnego przeszukiwania bity zmierzonego rozwiązania są losowo odwracane. Po odwróceniu oceniana jest energia nowego ciągu bitów. Jeśli energia jest niższa, ciąg bitów jest zachowywany jako nowe rozwiązanie. Lokalne przeszukiwanie skaluje się jedynie liniowo z liczbą Qubitów, jest więc obliczeniowo tanie. Ponieważ przetwarzanie końcowe koryguje lokalne odwrócenia bitów, kompensuje błędy odwrócenia bitów, które często są wynikiem niedoskonałości sprzętowych i błędów odczytu.

Przepływ pracy

Poniżej przedstawiono schemat przepływu pracy Quantum Optimizera.

Workflow

Korzystając z Quantum Optimizera, rozwiązanie problemu optymalizacyjnego na sprzęcie kwantowym można sprowadzić do:

Sformułowania funkcji celu problemu
Uzyskania dostępu do Optimizera przez Qiskit Functions
Uruchomienia Optimizera i zebrania wyników

Testy porównawcze

Poniższe wskaźniki testów porównawczych pokazują, że Optimizer skutecznie rozwiązuje problemy obejmujące do 156 Qubitów i oferują ogólny przegląd dokładności oraz skalowalności optimizera w różnych typach problemów. Zwróć uwagę, że rzeczywiste wskaźniki wydajności mogą się różnić w zależności od specyficznych właściwości problemu, takich jak liczba zmiennych, gęstość i lokalność terminów w funkcji celu oraz rząd wielomianu.

Poniższa tabela zawiera współczynnik aproksymacji (AR), który jest zdefiniowany następująco:

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

gdzie $C$ to funkcja celu, $C_{\textrm{min}}$ , $C_{\textrm{max}}$ to odpowiednio jej wartość minimalna i maksymalna, a $C^{*}$ to koszt najlepszego znalezionego rozwiązania. Zatem AR=100% oznacza, że uzyskano stan podstawowy problemu.

Przykład	Liczba Qubitów	Współczynnik aproksymacji	Łączny czas (s)	Czas użycia Runtime (s)	Łączna liczba pomiarów	Liczba iteracji
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

Instancje MaxCut z 28, 30 i 32 Qubitami były uruchamiane na ibm_sherbrooke. Instancje z 80, 100 i 120 Qubitami były uruchamiane na procesorze Heron r2.
Instancje HUBO były również uruchamiane na procesorze Heron r2.

Wszystkie instancje testów porównawczych są dostępne na GitHubie (zob. instancje testów Kipu). Przykład uruchomienia tych instancji można znaleźć w Przykładzie 3: Instancje testów porównawczych.

Pierwsze kroki

W tej dokumentacji przeprowadzimy cię przez kolejne etapy korzystania z Iskay Quantum Optimizer. Po drodze pokażemy, jak załadować funkcję z katalogu i jak przekształcić swój problem na prawidłowe dane wejściowe, demonstrując jednocześnie eksperymentowanie z różnymi opcjonalnymi parametrami.

Bardziej szczegółowy przykład znajdziesz w samouczku Rozwiąż problem podziału rynku z Iskay Quantum Optimizer od Kipu Quantum, w którym przechodzimy przez cały proces korzystania z Iskay Solver w celu rozwiązania problemu Market Split — rzeczywistego wyzwania alokacji zasobów, gdzie rynki muszą być podzielone na zrównoważone regiony sprzedaży spełniające dokładne cele popytu.

Uwierzytelnij się za pomocą klucza API, który znajdziesz na pulpicie nawigacyjnym IBM Quantum Platform, a następnie wybierz Qiskit Function w następujący sposób:

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

# ruff: noqa: F821

uwaga

Poniższy kod zakłada, że zapisałeś już swoje dane uwierzytelniające. Jeśli tego nie zrobiłeś, postępuj zgodnie z instrukcjami w sekcji zapisz swoje konto IBM Cloud, aby uwierzytelnić się za pomocą klucza 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")

Przykład niestandardowej konfiguracji

Oto jak możesz skonfigurować Iskay z różnymi ustawieniami:

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
}

Optymalizacja seed: Zwróć uwagę, że seed_transpiler jest domyślnie ustawiony na None. Umożliwia to automatyczny proces optymalizacji transpilera. Gdy wartość to None, system uruchomi próbę z wieloma seed'ami i wybierze ten, który zapewnia najlepszą głębokość obwodu, wykorzystując pełną moc parametru max_trials dla każdego poziomu transpilacji.

Wydajność poziomu transpilacji: Zwiększenie liczby max_trials z wyższymi wartościami transpilation_level nieuchronnie zwiększy czas transpilacji, ale może nie zawsze zmienić ostateczny obwód — zależy to w dużej mierze od konkretnej struktury obwodu i złożoności. Dla niektórych obwodów/problemów jednak różnica między 10 próbami (poziom 1) a 50 próbami (poziom 5) może być dramatyczna, więc eksploracja tych parametrów może być kluczem do pomyślnego znalezienia rozwiązania.

Przykład 1: Prosta funkcja kosztów

Rozważmy funkcję kosztów w sformułowaniu spinowym:

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

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

Rozwiązaniem tej prostej funkcji kosztów jest

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

z wartością minimalną $C^{*} = -6$

1. Utwórz funkcję celu

Zaczynamy od utworzenia słownika ze współczynnikami funkcji celu:

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

2. Uruchom Optimizer

Rozwiązujemy problem, uruchamiając optimizer. Ponieważ $(x_0, ..., x_4) \in \{-1, 1\}^5$ , musimy ustawić 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. Pobierz wynik

Rozwiązanie problemu optymalizacji jest dostarczane bezpośrednio przez optimizer.

print(job.result())

Wyświetlony zostanie słownik w następującej postaci:

{'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'}

Zauważ, że słownik solution wyświetla wektor wynikowy $(x_0, x_1, x_2, x_3, x_4) = (-1, -1, -1, 1, 1)$ .

Przykład 2: MaxCut

Wiele problemów grafowych, takich jak MaxCut czy maksymalny zbiór niezależny, to problemy NP-trudne i idealni kandydaci do testowania algorytmów kwantowych i sprzętu. Ten przykład demonstruje rozwiązanie problemu MaxCut dla grafu 3-regularnego za pomocą Quantum Optimizer.

Aby uruchomić ten przykład, musisz zainstalować pakiet networkx oprócz qiskit-ibm-catalog. Aby go zainstalować, uruchom następujące polecenie:

# %pip install networkx numpy

1. Utwórz funkcję celu

Zacznij od wygenerowania losowego grafu 3-regularnego. Dla tego grafu definiujemy funkcję celu problemu 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. Uruchom Optimizer

Rozwiąż problem, uruchamiając 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. Pobierz wynik

Pobierz wynik i odwzoruj ciąg bitów rozwiązania z powrotem na węzły oryginalnego grafu.

print(job.result())

Rozwiązanie problemu MaxCut jest bezpośrednio zawarte w pod-słowniku solution obiektu wynikowego

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

Przykład 3: Instancje benchmarkowe

Instancje benchmarkowe są dostępne na GitHub: Instancje benchmarkowe Kipu.

Instancje można załadować za pomocą biblioteki pygithub. Aby ją zainstalować, uruchom następujące polecenie:

# %pip install pygithub

Ścieżki do instancji benchmarkowych:

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'

Aby odtworzyć wydajność benchmarku dla instancji HUBO, wybierz Backend ibm_marrakesh i ustaw direct_qubit_mapping na True w pod-słowniku options. Poniższy przykład uruchamia instancję Maxcut z 150 węzłami.

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()

Przypadki użycia

Typowe przypadki użycia solvera optymalizacyjnego to kombinatoryczne problemy optymalizacyjne. Możesz rozwiązywać problemy z wielu branż, takich jak finanse, farmacja czy logistyka. Poniżej kilka przykładów.

Optymalizacja portfela (QUBO): publikacja naukowa i biała księga
Składanie białek (HUBO): publikacja naukowa
Harmonogramowanie logistyczne (QUBO): publikacja naukowa
Optymalizacja sieci: webinar
Podział rynku (QUBO): samouczek

Jeśli interesuje cię rozwiązanie konkretnego przypadku użycia i opracowanie dedykowanego odwzorowania, możemy ci w tym pomóc. Skontaktuj się z nami.

Uzyskaj wsparcie

W sprawie wsparcia skontaktuj się z support@kipu-quantum.com.

Następne kroki

Poproś o dostęp do Quantum Optimizer od Kipu Quantum.
Odwiedź dokumentację API dla tej funkcji Qiskit.
Wypróbuj samouczek Rozwiąż problem podziału rynku z Iskay Quantum Optimizer od Kipu Quantum.
Zapoznaj się z Romero, S. V., et al. (2025). Bias-Field Digitized Counterdiabatic Quantum Algorithm for Higher-Order Binary Optimization. arXiv preprint arXiv:2409.04477.
Zapoznaj się z Cadavid, A. G., et al. (2024). Bias-field digitized counterdiabatic quantum optimization. arXiv preprint arXiv:2405.13898.
Zapoznaj się z Chandarana, P., et al. (2025). Runtime Quantum Advantage with Digital Quantum Optimization. arXiv preprint arXiv:2505.08663.

Dodatkowe informacje

Iskay, podobnie jak nazwa naszej firmy Kipu Quantum, jest słowem peruwiańskim. Chociaż jesteśmy startupem z Niemiec, słowa te pochodzą z ojczyzny jednego z naszych współzałożycieli, gdzie Quipu był jednym z pierwszych urządzeń obliczeniowych stworzonych przez ludzkość 2000 lat p.n.e.

Przegląd​

Opis​

Jak działa Quantum Optimizer?​

Przepływ pracy​

Testy porównawcze​

Pierwsze kroki​

Przykład niestandardowej konfiguracji​

Przykład 1: Prosta funkcja kosztów​

1. Utwórz funkcję celu​

2. Uruchom Optimizer​

3. Pobierz wynik​

Przykład 2: MaxCut​

1. Utwórz funkcję celu​

2. Uruchom Optimizer​

3. Pobierz wynik​

Przykład 3: Instancje benchmarkowe​

Przypadki użycia​

Uzyskaj wsparcie​

Następne kroki​

Dodatkowe informacje​

Przegląd

Opis

Jak działa Quantum Optimizer?

Przepływ pracy

Testy porównawcze

Pierwsze kroki

Przykład niestandardowej konfiguracji

Przykład 1: Prosta funkcja kosztów

1. Utwórz funkcję celu

2. Uruchom Optimizer

3. Pobierz wynik

Przykład 2: MaxCut

1. Utwórz funkcję celu

2. Uruchom Optimizer

3. Pobierz wynik

Przykład 3: Instancje benchmarkowe

Przypadki użycia

Uzyskaj wsparcie

Następne kroki

Dodatkowe informacje