SQOA Solver - Qiskit Function firmy JIJ

Zobacz dokumentację API.

uwaga

Qiskit Functions 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ą status wersji zapoznawczej i mogą ulec zmianie.

Przegląd

Dzięki SQOA Solver firmy JIJ możesz rozwiązywać duże kombinatoryczne problemy optymalizacyjne na komputerach kwantowych IBM®. Solver opiera się na algorytmie Sampling-based Quantum Optimization Algorithm with Quantum Relaxation (SQOA-QR) [1]. W odróżnieniu od algorytmów kwantowych, które stosują odwzorowanie jeden do jednego między klasycznymi zmiennymi decyzyjnymi a kubitami, SQOA Solver potrafi obsługiwać problemy optymalizacyjne z liczbą zmiennych większą niż liczba kubitów dostępnych w obecnych urządzeniach kwantowych. Jego konstrukcja oparta na próbkowaniu sprawia też, że jest mniej wrażliwy na fizyczny szum w obecnym sprzęcie kwantowym. Dzięki tym cechom SQOA Solver dobrze nadaje się do problemów optymalizacyjnych na obecnym etapie rozwoju obliczeń kwantowych.

Solver obsługuje problemy Quadratic Unconstrained Binary Optimization (QUBO) podane w klasycznym sformułowaniu matematycznym i automatycznie odwzorowuje je na ustawienie kwantowe. Problemy z ograniczeniami możesz też przekształcić w problemy bez ograniczeń za pomocą metody kar.

Poniższe sekcje opisują przepływ pracy solvera, wyniki testów wydajności oraz kompletne przykłady, które modelują problemy za pomocą qiskit-addon-opt-mapper i, opcjonalnie, Open Mathematical prograMming eXchange (OMMX). OMMX to otwarty format danych i SDK, które upraszczają wymianę problemów optymalizacyjnych między narzędziami programistycznymi.

Opis

SQOA Solver implementuje algorytm Sampling-based Quantum Optimization Algorithm with Quantum Relaxation (SQOA-QR) i otacza go klasycznym przetwarzaniem wstępnym i końcowym. Ta sekcja wyjaśnia framework SQOA oraz jego różnice względem Quantum Approximate Optimization Algorithm (QAOA).

Poniższy rysunek przedstawia schemat przepływu pracy SQOA Solver.

Framework SQOA

SQOA to oparty na próbkowaniu framework do optymalizacji kombinatorycznej [1]. Łączy dwie techniki: Quantum Random Access Optimization (QRAO) [2], która koduje problem w relaksacji kwantowej, oraz próbkową diagonalizację kwantową (SQD) [3], znaną też jako quantum-selected configuration interaction (QSCI) [4], która używa komputera kwantowego wyłącznie do próbkowania ciągów bitów, a stan o najniższej energii znajduje na komputerze klasycznym. SQOA jest frameworkiem w tym sensie, że ustala to połączenie, ale szczegóły pozostawia każdej implementacji, na przykład sposób przypisania zmiennych do kubitów i to, które obwody generują próbki.

• Relaksacja kwantowa z QRAO. QAOA i inne podejścia oparte na modelu Isinga reprezentują każdą zmienną binarną za pomocą operatora $Z$ jej kubitu. QRAO wykorzystuje także operatory $X$ i $Y$. Przy kwantowym kodzie dostępu losowego (QRAC) (3,1) do trzech zmiennych binarnych dzieli jeden kubit, a każda zmienna jest reprezentowana przez inny operator Pauliego.

  QUBO staje się wtedy zrelaksowanym hamiltonianem, który wymaga mniej kubitów niż hamiltonian Isinga. Zmienne, które oddziałują w QUBO, muszą być umieszczone na różnych kubitach. Gdyby dzieliły kubit, iloczyn ich operatorów Pauliego sprowadziłby się do pojedynczego operatora na tym kubicie (na przykład $XY = iZ$), a zrelaksowany hamiltonian przestałby reprezentować ich oddziaływanie.

  Przypisanie zmiennych do kubitów determinuje więc zarówno liczbę kubitów, jak i jakość relaksacji, a SQOA Solver projektuje to przypisanie w przetwarzaniu wstępnym.

• Próbkowa diagonalizacja kwantowa (SQD). Komputer kwantowy najpierw przygotowuje stan kwantowy, który pokrywa się ze stanami o niskiej energii zrelaksowanego hamiltonianu, a następnie próbkuje z niego ciągi bitów. Komputer klasyczny rzutuje zrelaksowany hamiltonian na podprzestrzeń rozpiętą przez spróbkowane ciągi bitów i diagonalizuje go, aby przybliżyć stan podstawowy.

  Ponieważ zrelaksowany hamiltonian nie jest diagonalny, diagonalizacja łączy spróbkowane ciągi bitów w superpozycję. Przy diagonalnym hamiltonianie Isinga każdy ciąg bitów jest już stanem własnym, a diagonalizacja wybrałaby jedynie najlepszą próbkę. To samo podejście zastosowano do problemów wielkoskalowych w chemii kwantowej.

Przybliżony stan podstawowy uzyskany przez SQD nie odpowiada bezpośrednio klasycznemu rozwiązaniu pierwotnego problemu, więc rozwiązanie klasyczne trzeba z niego zdekodować. Ponieważ ten stan jest obliczany na komputerze klasycznym, dekodowanie, zwane zaokrąglaniem, jest klasycznym przetwarzaniem końcowym. SQOA Solver stosuje techniki dekodowania zaprojektowane tak, aby heurystycznie uzyskiwać lepsze rozwiązania klasyczne.

Poniższa tabela porównuje SQOA z QAOA, czyli popularnym podejściem wariacyjnym do tej samej klasy problemów.

	QAOA	SQOA
Kubity dla $n$ zmiennych binarnych	$n$	Jeden kubit przechowuje do trzech zmiennych. Dokładna liczba zależy od struktury problemu
Użycie QPU	Wielokrotnie szacuje energię parametryzowanych obwodów w klasycznej pętli optymalizacji	Tylko próbkuje ciągi bitów. Na QPU nie trenuje się żadnych parametrów obwodu
Od próbek do rozwiązania	Wybiera najlepszy zmierzony ciąg bitów	Diagonalizuje zrelaksowany hamiltonian w spróbkowanej podprzestrzeni na komputerze klasycznym i zaokrągla otrzymany stan

Wokół SQOA-QR SQOA Solver dodaje przetwarzanie klasyczne. Jego przetwarzanie wstępne ustala zmienne, których optymalne wartości można określić z góry, i projektuje przypisanie zmiennych do kubitów. Jego przetwarzanie końcowe doprecyzowuje zaokrąglone rozwiązanie za pomocą wyszukiwania lokalnego, które możesz wyłączyć przez postprocessing_level=0.

Testy wydajności

Zastrzeżenie

Wydajność może zależeć zarówno od konkretnej instancji problemu, jak i od kolejnych kroków przetwarzania. W niektórych przypadkach próbki klasyczne i próbki wygenerowane kwantowo mogą po równoważnym przetwarzaniu końcowym osiągać podobną jakość końcowego rozwiązania. Ocena powinna więc uwzględniać cały przepływ optymalizacji.

Poniższe metryki testów wydajności dają ogólny obraz jakości rozwiązań, kompresji kubitów i czasu wykonania dla wybranych rozmiarów i struktur problemów. Tabela zawiera wybrane instancje problemu maksymalnego zbioru niezależnego z Quantum Optimization Benchmarking Library (QOBLIB) oraz dwie 3-regularne instancje MaxCut. Instancje QOBLIB możesz wczytać jako obiekty ommx.v1.Instance wraz z ich rozwiązaniami optymalnymi za pomocą pakietu ommx-quantum-benchmarks.

Każdą instancję uruchomiono 10 razy na procesorze IBM Heron r2. Number of qubits to liczba kubitów faktycznie użytych na sprzęcie po przetwarzaniu wstępnym i kodowaniu QRAC. Współczynnik kompresji zależy od instancji. Approximation ratio (AR) opisuje jakość najlepszego rozwiązania znalezionego w 10 uruchomieniach:

$$\mathrm{AR} = \frac{C_{\textrm{best}}}{C_{\textrm{opt}}},$$

gdzie $C_{\textrm{best}}$ to najlepsza znaleziona wartość funkcji celu, a $C_{\textrm{opt}}$ to znana optymalna wartość funkcji celu. Wszystkie instancje są problemami maksymalizacji z dodatnią wartością optymalną, więc AR wynosi co najwyżej 100%, a 100% w kolumnie Approximation ratio oznacza, że solver znalazł rozwiązanie optymalne. Total time to średni łączny czas QPU i CPU na uruchomienie. QPU time to średnie zużycie IBM Quantum Compute na uruchomienie.

Instancja	Liczba zmiennych	Liczba kubitów	Współczynnik aproksymacji	Czas całkowity (sekundy)	Czas QPU (sekundy)
maxcut_384_nodes	384	129	98.5%	62.1	12.0
gen200_p0-9_44	200	67	100%	38.0	12.0
es60fst02	186	42	100%	24.7	12.0
es60fst04	162	29	100%	17.9	12.0
maxcut_150_nodes	150	51	100%	23.1	12.0
sloane_1dc_128	128	37	93.8%	19.1	12.0
sloane_2dc_128	128	8	100%	12.3	11.5
C125-9	125	43	100%	22.3	12.0
es60fst01	123	12	100%	13.6	12.0
es60fst03	113	26	100%	14.9	12.0
sloane_1dc_64	64	16	100%	13.4	11.9
chesapeake	39	13	100%	13.1	12.0
football	35	6	100%	12.5	12.0
karate	34	2	100%	6.2	6.0
ibm32	32	11	100%	12.9	12.0
farm	17	4	100%	8.5	8.0

Pierwsze kroki

Informacje o dostępie do tej funkcji Qiskit Function znajdziesz w Qiskit Functions Catalog.

Ta sekcja pokazuje, jak uwierzytelnić się i wczytać funkcję oraz jak przygotować problem w formacie słownika akceptowanym przez SQOA Solver, używając OptimizationProblem z qiskit-addon-opt-mapper. Kolejne przykłady uruchamiają funkcję i odczytują wynik.

Uwierzytelnianie i wczytanie funkcji

Najpierw uwierzytelnij się za pomocą klucza API IBM Quantum. (Poniższy kod zakłada, że zapisano już Twoje konto w lokalnym środowisku.) Następnie utwórz klienta katalogu w następujący sposób:

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"jijmodeling": "jijmodeling", "networkx": "networkx", "ommx": "ommx", "qiskit_addon_opt_mapper": "qiskit-addon-opt-mapper", "qiskit_ibm_catalog": "qiskit-ibm-catalog"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

from qiskit_ibm_catalog import QiskitFunctionsCatalog

catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")

# verify that you have access to the function
catalog.list()

[QiskitFunction(jij/sqoa-solver)]

solver = catalog.load("jij/sqoa-solver")

Przygotowanie danych wejściowych za pomocą qiskit-addon-opt-mapper

Ten przewodnik modeluje problemy za pomocą klasy OptimizationProblem z qiskit-addon-opt-mapper. SQOA Solver przyjmuje problem QUBO jako słownik współczynników w formacie krotek zapisanych jako ciągi znaków, używanym przez funkcje optymalizacyjne IBM, więc każdy przykład w tym przewodniku stosuje ten sam wzorzec przygotowania po stronie klienta:

1. Napisz model. Utwórz OptimizationProblem, dodaj binarne zmienne decyzyjne i ustaw funkcję celu oraz ewentualne ograniczenia.

2. Przekształć do QUBO. Przekształć problem za pomocą OptimizationProblemToQubo, który dodaje ewentualne ograniczenia do funkcji celu jako składniki kary i zwraca równoważny problem minimalizacji bez ograniczeń.

3. Przekształć do słownika. Przekaż QUBO do funkcji pomocniczej to_problem_dict() zdefiniowanej w następnej sekcji, a wynik przekaż do solver.run() jako problem, razem z variable_type="binary".

SQOA Solver zawsze minimalizuje problem w postaci słownika, co odpowiada problemowi minimalizacji zwracanemu przez OptimizationProblemToQubo. Dla problemu maksymalizacji zwrócona wartość objective_value jest więc przeciwna do oryginalnej funkcji celu. Aby odczytać wynik w kategoriach pierwotnego problemu, oceń zwrócone przypisanie za pomocą OptimizationProblem, jak pokazują przykłady. Szczegóły formatu słownika znajdziesz w sekcji Accepted problem formats w dokumentacji API.

# %pip install qiskit-addon-opt-mapper

Zdefiniuj poniższą funkcję pomocniczą raz i używaj jej w każdym przykładzie. Przekształca ona QUBO zwrócone przez OptimizationProblemToQubo do formatu słownika. Klucze używają indeksów zmiennych QUBO, więc klucze rozwiązania x_0, x_1 itd. w wyniku odpowiadają tym indeksom. Każda zmienna otrzymuje wpis liniowy, nawet przy zerowym współczynniku, aby zwrócone rozwiązanie obejmowało wszystkie zmienne.

from qiskit_addon_opt_mapper import OptimizationProblem
from qiskit_addon_opt_mapper.converters import OptimizationProblemToQubo

def to_problem_dict(qubo: OptimizationProblem) -> dict[str, float]:
    """Convert a QUBO from OptimizationProblemToQubo to the SQOA Solver dictionary format."""
    objective = qubo.objective
    payload = {"()": objective.constant}
    # Keep every variable in the problem, even with a zero linear coefficient.
    payload.update({f"({i},)": 0.0 for i in range(qubo.get_num_vars())})
    for i, coefficient in objective.linear.to_dict().items():
        payload[f"({i},)"] += coefficient
    for (i, j), coefficient in objective.quadratic.to_dict().items():
        # Fold a binary diagonal term x_i * x_i = x_i into the linear term.
        key = f"({i},)" if i == j else f"({i}, {j})"
        payload[key] = payload.get(key, 0.0) + coefficient
    return {key: float(value) for key, value in payload.items()}

Przykład 1: MaxCut na grafie 3-regularnym

Wiele problemów grafowych, takich jak MaxCut, jest NP-trudnych i stanowi naturalnych kandydatów do optymalizacji kwantowej. Zainstaluj networkx jako dodatkową zależność, aby uruchomić ten przykład:

# %pip install networkx

1. Napisz model

Przypisz zmienną binarną $x_v \in \{0, 1\}$ każdemu wierzchołkowi grafu $G = (V, E)$, aby wskazać jego stronę cięcia. Krawędź jest przecięta, gdy jej końce leżą po różnych stronach, więc rozmiar cięcia wynosi:

$$\mathrm{Cut}(x) = \sum_{(u,v) \in E} \left(x_u + x_v - 2 x_u x_v\right).$$

Ta funkcja celu jest już problemem QUBO bez ograniczeń, więc OptimizationProblemToQubo jedynie zamienia maksymalizację na równoważną minimalizację i pozostawia zmienne bez zmian. Klasa aplikacji Maxcut w qiskit_addon_opt_mapper.applications buduje ten sam model za pomocą Maxcut(G).to_optimization_problem().

import networkx as nx

G = nx.random_regular_graph(3, 40, seed=42)

linear = {v: 0 for v in G.nodes}
quadratic = {}
for u, v in G.edges:
    linear[u] += 1
    linear[v] += 1
    quadratic[(u, v)] = -2

maxcut = OptimizationProblem("MaxCut")
maxcut.binary_var_list(G.number_of_nodes(), name="x")
maxcut.maximize(linear=linear, quadratic=quadratic)

2. Uruchom solver

Przekształć model do QUBO, a następnie do słownika i prześlij go. Parametry problem i variable_type są wymagane. Parametr backend_name jest opcjonalny. Gdy go pominiesz lub ustawisz na None, funkcja wybiera najmniej obciążone działające QPU dostępne dla Twojej instancji.

Słownik options akceptuje shots, seed, session, postprocessing_level i job_tags. Opisy i wartości domyślne znajdziesz w dokumentacji API.

qubo = OptimizationProblemToQubo().convert(maxcut)

job = solver.run(
    problem=to_problem_dict(qubo),
    variable_type="binary",
    backend_name="ibm_fez",
    options={
        "shots": 4096,
        "seed": 42,
    },
)

3. Pobierz wynik

job.result() zwraca słownik z czterema kluczami:

• solution to kompletne przypisanie zmiennych, indeksowane kluczami x_i, gdzie i to indeks zmiennej (na przykład x_3).

• objective_value i feasible to wartość funkcji celu i dopuszczalność tego przypisania, obliczone na przesłanym słowniku.

• metadata zawiera solver_info i resource_usage.

Ponieważ QUBO jest postacią minimalizacyjną MaxCut, objective_value jest przeciwna do rozmiaru cięcia. Oceń przypisanie na pierwotnym OptimizationProblem, aby odczytać rozmiar cięcia bezpośrednio.

result = job.result()

x = [result["solution"][f"x_{i}"] for i in range(maxcut.get_num_vars())]
print(f"Cut value: {maxcut.objective.evaluate(x)}")
print(f"Nodes on side 1: {[v for v, value in enumerate(x) if value > 0.5]}")

Cut value: 55.0
Nodes on side 1: [5, 7, 9, 11, 14, 16, 17, 19, 21, 23, 24, 26, 30, 31, 33, 34, 36, 37, 38]

4. Sprawdź zużycie zasobów

result["metadata"]["resource_usage"] raportuje czas spędzony w każdej fazie wykonania. Fazy inne niż RUNNING: EXECUTING_QPU raportują CPU_TIME, czyli czas zegarowy fazy w sekundach, jeśli jest dostępny.

Faza RUNNING: EXECUTING_QPU raportuje QPU_TIME, czyli zużycie QPU wszystkich zadań Quantum Compute w danym uruchomieniu, jeśli końcowe zużycie jest dostępne dla każdego zadania. Szczegóły znajdziesz w dokumentacji API.

for phase, metrics in result["metadata"]["resource_usage"].items():
    line = f"{phase:36s}"
    if "CPU_TIME" in metrics:
        line += f" CPU {metrics['CPU_TIME']:8.1f} s"
    if "QPU_TIME" in metrics:
        line += f" QPU {metrics['QPU_TIME']:8.1f} s"
    print(line)

RUNNING: MAPPING                     CPU      3.2 s
RUNNING: OPTIMIZING_FOR_HARDWARE     CPU      5.0 s
RUNNING: WAITING_FOR_QPU             CPU      1.1 s
RUNNING: EXECUTING_QPU               QPU      3.0 s
RUNNING: POST_PROCESSING             CPU      0.9 s

Przykład 2: Przekształcenie problemu z ograniczeniami do QUBO

SQOA Solver akceptuje problemy bez ograniczeń. Ten przykład pokazuje, jak przekształcić problem z ograniczeniami do QUBO za pomocą OptimizationProblemToQubo i odwzorować wynik z powrotem na zmienne pierwotnego problemu.

selection = OptimizationProblem("ConstrainedExample")
selection.binary_var_list(2, name="x")
selection.maximize(linear={"x0": 1, "x1": 1})
selection.linear_constraint({"x0": 1, "x1": 1}, "<=", 1, name="at_most_one")

print(selection.prettyprint())

Problem name: ConstrainedExample

Maximize
  x0 + x1

Subject to
  Linear constraints (1)
    x0 + x1 <= 1  'at_most_one'

  Binary variables (2)
    x0 x1

OptimizationProblemToQubo dodaje ograniczenia do funkcji celu jako składniki kary i przekształca problem w minimalizację. Odpowiednia waga kary zależy od problemu.

Po uruchomieniu interpret() odwzorowuje przypisanie QUBO z powrotem na zmienne pierwotnego problemu.

Oceń funkcję celu i dopuszczalność na pierwotnym problemie. W przypadku problemu w postaci słownika pole feasible w wyniku dotyczy wyłącznie dziedziny zmiennych, ponieważ słownik nie zawiera ograniczeń.

converter = OptimizationProblemToQubo(penalty=4.0)
qubo = converter.convert(selection)

job = solver.run(
    problem=to_problem_dict(qubo),
    variable_type="binary",
    backend_name="ibm_fez",
)
result = job.result()

x_qubo = [result["solution"][f"x_{i}"] for i in range(qubo.get_num_vars())]
x = converter.interpret(x_qubo)
print("Objective:", selection.objective.evaluate(x))
print("Feasible:", selection.is_feasible(x))
print("x values:", x)

Objective: 1.0
Feasible: True
x values: [1. 0.]

Przykład 3: Przesłanie instancji OMMX

SQOA Solver akceptuje także ommx.v1.Instance z SDK OMMX, która przechowuje nazwy zmiennych, indeksy i metadane konwersji razem z problemem. W porównaniu ze słownikiem dane wejściowe OMMX mają następujące zalety:

• Wynik zawiera też kanoniczne ommx.v1.Solution w solver_info["ommx_solution"].

• objective_value jest obliczana w sensie instancji, więc funkcja celu problemu maksymalizacji nie jest negowana.

• Dla instancji przekształconej w miejscu za pomocą Instance.to_qubo() wartość feasible jest oceniana względem pierwotnych ograniczeń.

Ten przykład buduje model MaxCut z przykładu 1 za pomocą JijModeling, modelera optymalizacji matematycznej, który kompiluje modele do instancji OMMX. Zainstaluj JijModeling, który instaluje też pakiet ommx:

# %pip install "jijmodeling~=2.8.0"

SQOA Solver wymienia dane OMMX jako standardowe ciągi Base64 z dopełnieniem. Zdefiniuj poniższe funkcje pomocnicze do tej konwersji:

• to_problem_payload() serializuje ommx.v1.Instance do ciągu znaków, który przekazujesz jako problem.

• to_ommx_solution() dekoduje z wyniku kanoniczne ommx.v1.Solution.

import base64

from ommx.v1 import Instance, Solution

def to_problem_payload(instance: Instance) -> str:
    """Serialize an OMMX instance into the `problem` string for SQOA Solver."""
    return base64.b64encode(instance.to_bytes()).decode()

def to_ommx_solution(result: dict) -> Solution:
    """Decode the canonical OMMX solution from a SQOA Solver result."""
    payload = result["metadata"]["solver_info"]["ommx_solution"]
    return Solution.from_bytes(base64.b64decode(payload, validate=True))

1. Napisz model za pomocą JijModeling

Zwykłe sformułowanie spinowe MaxCut na grafie $G = (V, E)$ przypisuje $s_v \in \{-1, +1\}$ każdemu wierzchołkowi. Krawędź jest przecięta, gdy $s_u s_v = -1$, więc rozmiar cięcia wynosi:

$$\operatorname{Cut}(s) = \sum_{(u,v) \in E} \frac{1 - s_u s_v}{2}.$$

JijModeling nie udostępnia natywnej spinowej zmiennej decyzyjnej, a SQOA Solver akceptuje binarne zmienne QUBO. Dlatego zadeklaruj $b_v \in \{0, 1\}$ i zdefiniuj wyrażenie o wartościach spinowych $s_v = 1 - 2b_v$ wewnątrz modelu. Dzięki temu wyrażeniu funkcja celu pozostaje w standardowej postaci spinowej, a skompilowana instancja pozostaje binarnym QUBO.

import jijmodeling as jm

@jm.Problem.define("MaxCut", sense=jm.ProblemSense.MAXIMIZE)
def maxcut_model(problem: jm.DecoratedProblem):
    V = problem.Natural()  # number of nodes
    E = problem.Graph(dtype=V)  # edge list
    b = problem.BinaryVar(shape=(V,))
    s = 1 - 2 * b  # spin-valued expression

    problem += jm.sum((1 - s[u] * s[v]) / 2 for u, v in E)

Jeśli wyświetlisz maxcut_model w notatniku, zobaczysz następujące sformułowanie:

$$\begin{array}{rl} \text{Problem}\colon &\text{MaxCut}\\ \displaystyle \max &\displaystyle \sum _{\left\langle u,v\right\rangle \in E}{\frac{1-{\left(1-2\cdot b\right)}_{u}\cdot {\left(1-2\cdot b\right)}_{v}}{2}}\\ &\\ \text{where}&\\ &\text{Decision Variables:}\\ &\qquad \begin{alignedat}{2}{b}_{i}&\in \left\{0,1\right\}&\qquad &\text{a }1\text{-dim array of }\text{binary}\text{ decision variables}\\ &\forall i\in \left\{0,\ldots ,V-1\right\}&&\\ \end{alignedat}\\ &\\ &\text{Placeholders:}\\ &\qquad \begin{alignedat}{2}{E}_{i}&\in V\times V&\qquad &\text{a }1\text{-dim array of placeholders with elements in }V\times V\\ &\forall i\in \left\{0,\ldots ,\mathop{\mathtt{len\_{}at}}\left(E,0\right)-1\right\}&&\\ &&&\\ V&\in \mathbb{N}&\qquad &\text{a scalar placeholder in }\mathbb{N}\\ \end{alignedat}\end{array}$$

2. Skompiluj instancję i uruchom solver

Powiąż graf z przykładu 1, aby skompilować ommx.v1.Instance, i prześlij go z variable_type="binary". Instancja OMMX jest zawsze przesyłana jako problem binarny.

instance = maxcut_model.eval(
    {"V": G.number_of_nodes(), "E": [list(edge) for edge in G.edges]}
)

job = solver.run(
    problem=to_problem_payload(instance),
    variable_type="binary",
    backend_name="ibm_fez",
)

3. Pobierz wynik

Dla danych wejściowych OMMX objective_value to rozmiar cięcia, a to_ommx_solution() dekoduje kanoniczne rozwiązanie, dzięki czemu możesz odczytać przypisanie według nazw zmiennych.

result = job.result()
print(f"Cut value: {result['objective_value']}")

solution = to_ommx_solution(result)
b_values = solution.extract_decision_variables("b")
print(
    f"Nodes on side 1: {sorted(v for (v,), value in b_values.items() if value > 0.5)}"
)

Cut value: 55.0
Nodes on side 1: [5, 7, 9, 11, 14, 16, 17, 19, 21, 23, 24, 26, 30, 31, 33, 34, 36, 37, 38]

Uzyskaj pomoc

Aby uzyskać pomoc, napisz na adres info@j-ij.com.

Następne kroki

Zalecenia

• Poproś o bezpłatną wersję próbną SQOA Solver, wypełniając ten formularz.
• Odwiedź dokumentację API tej funkcji Qiskit Function.
• Wypróbuj kompletny przykład w samouczku problem maksymalnego zbioru niezależnego.
• Dowiedz się, jak modelować problemy optymalizacyjne za pomocą qiskit-addon-opt-mapper.
• Dowiedz się, jak modelować i wymieniać problemy optymalizacyjne za pomocą JijModeling i OMMX.
• Przeczytaj artykuł o SQOA-QR [1], aby dowiedzieć się więcej o frameworku SQOA.

Bibliografia

[1] Matsuyama, H., & Yamashiro, Y. (2025). Sampling-based quantum optimization algorithm with quantum relaxation. 2025 IEEE International Conference on Quantum Computing and Engineering (QCE), 1, 2323–2333. DOI, arXiv:2504.12629

[2] Fuller, B., Hadfield, C., Glick, J. R., Imamichi, T., Itoko, T., Thompson, R. J., Jiao, Y., Kagele, M. M., Blom-Schieber, A. W., Raymond, R., et al. (2024). Approximate solutions of combinatorial problems via quantum relaxations. IEEE Transactions on Quantum Engineering, 5, 1–15. DOI, arXiv:2111.03167

[3] Robledo-Moreno, J., Motta, M., Haas, H., Javadi-Abhari, A., Jurcevic, P., Kirby, W., et al. (2025). Chemistry beyond the scale of exact diagonalization on a quantum-centric supercomputer. Science Advances, 11(25), eadu9991. DOI, arXiv:2405.05068

[4] Kanno, K., Kohda, M., Imai, R., Koh, S., Mitarai, K., Mizukami, W., & Nakagawa, Y. O. (2026). Quantum-selected configuration interaction: Classical diagonalization of Hamiltonians in subspaces selected by quantum computers. Physical Review Research, 8(2), 023268. DOI, arXiv:2302.11320