SQOA Solver - Qiskit Function dari JIJ

Lihat referensi API.

catatan

Qiskit Functions adalah fitur eksperimental yang hanya tersedia untuk pengguna IBM Quantum® Premium Plan, Flex Plan, dan On-Prem (via IBM Quantum Platform API) Plan. Fitur ini berstatus rilis preview dan dapat berubah.

Ringkasan

Dengan SQOA Solver dari JIJ, kamu bisa menyelesaikan masalah optimisasi kombinatorial berskala besar di komputer kuantum IBM®. Solver ini berbasis Sampling-based Quantum Optimization Algorithm with Quantum Relaxation (SQOA-QR) [1]. Berbeda dengan algoritma kuantum yang memakai pemetaan satu-ke-satu antara variabel keputusan klasik dan qubit, SQOA Solver bisa menangani masalah optimisasi dengan jumlah variabel lebih banyak daripada jumlah qubit yang tersedia di perangkat kuantum saat ini. Desainnya yang berbasis sampling juga membuatnya kurang sensitif terhadap noise fisik pada hardware kuantum saat ini. Gabungan fitur-fitur ini membuat SQOA Solver cocok untuk masalah optimisasi pada tahap komputasi kuantum sekarang.

Solver ini menangani masalah Quadratic Unconstrained Binary Optimization (QUBO) yang diberikan sebagai formulasi matematika klasik, lalu otomatis memetakan formulasi klasik itu ke ranah kuantum. Kamu juga bisa mengubah masalah berkendala menjadi masalah tanpa kendala dengan metode penalti.

Bagian-bagian berikut menjelaskan alur kerja solver, hasil benchmark, dan contoh end-to-end yang memodelkan masalah dengan qiskit-addon-opt-mapper dan, secara opsional, Open Mathematical prograMming eXchange (OMMX). OMMX adalah format data terbuka sekaligus SDK yang menyederhanakan pertukaran masalah optimisasi antar perangkat lunak.

Deskripsi

SQOA Solver mengimplementasikan Sampling-based Quantum Optimization Algorithm with Quantum Relaxation (SQOA-QR) dan membungkusnya dengan preprocessing dan postprocessing klasik. Bagian ini menjelaskan kerangka SQOA dan apa bedanya dengan Quantum Approximate Optimization Algorithm (QAOA).

Gambar berikut menunjukkan skema alur kerja SQOA Solver.

Kerangka SQOA

SQOA adalah kerangka berbasis sampling untuk optimisasi kombinatorial [1]. Kerangka ini menggabungkan dua teknik: Quantum Random Access Optimization (QRAO) [2], yang menyandikan masalah dalam quantum relaxation, dan sample-based quantum diagonalization (SQD) [3], yang juga dikenal sebagai quantum-selected configuration interaction (QSCI) [4], yang memakai komputer kuantum hanya untuk mengambil sampel bitstring dan mencari keadaan berenergi rendah di komputer klasik. SQOA disebut kerangka karena menetapkan kombinasi ini tetapi menyerahkan detailnya ke tiap implementasi, seperti cara variabel ditugaskan ke qubit dan circuit mana yang menghasilkan sampel.

• Quantum relaxation dengan QRAO. QAOA dan pendekatan berbasis Ising lainnya merepresentasikan setiap variabel biner dengan operator $Z$ dari qubit-nya. QRAO juga memakai operator $X$ dan $Y$. Dengan (3,1) quantum random access code (QRAC), hingga tiga variabel biner berbagi satu qubit, dan setiap variabel direpresentasikan oleh operator Pauli yang berbeda.

  QUBO kemudian menjadi Hamiltonian relaxed yang membutuhkan lebih sedikit qubit daripada Hamiltonian Ising. Variabel yang berinteraksi di QUBO harus ditempatkan pada qubit yang berbeda. Kalau mereka berbagi satu qubit, hasil kali operator Pauli-nya akan menyusut menjadi satu operator pada qubit itu (misalnya, $XY = iZ$), dan Hamiltonian relaxed tidak lagi merepresentasikan interaksi mereka.

  Karena itu, penugasan variabel ke qubit menentukan jumlah qubit sekaligus kualitas relaxation, dan SQOA Solver merancang penugasan ini pada tahap preprocessing-nya.

• Sample-based quantum diagonalization (SQD). Komputer kuantum lebih dulu menyiapkan keadaan kuantum yang beririsan dengan keadaan berenergi rendah dari Hamiltonian relaxed, lalu mengambil sampel bitstring darinya. Komputer klasik memproyeksikan Hamiltonian relaxed ke subruang yang direntang oleh bitstring hasil sampling dan mendiagonalkannya untuk mengaproksimasi ground state.

  Karena Hamiltonian relaxed bersifat non-diagonal, diagonalisasi menggabungkan bitstring hasil sampling menjadi superposisi. Pada Hamiltonian Ising yang diagonal, setiap bitstring sudah merupakan eigenstate, dan diagonalisasi hanya akan memilih sampel terbaik. Pendekatan yang sama sudah diterapkan pada masalah berskala besar di kimia kuantum.

Ground state aproksimasi yang diperoleh dari SQD tidak langsung sesuai dengan solusi klasik dari masalah aslinya, jadi solusi klasik harus didekode darinya. Karena keadaan ini dihitung di komputer klasik, dekode yang disebut rounding ini merupakan postprocessing klasik. SQOA Solver memakai teknik dekode yang dirancang untuk memperoleh solusi klasik yang lebih baik secara heuristik.

Tabel berikut membandingkan SQOA dengan QAOA, pendekatan variasional umum untuk kelas masalah yang sama.

	QAOA	SQOA
Qubit untuk $n$ variabel biner	$n$	Satu qubit memuat hingga tiga variabel. Jumlah pastinya bergantung pada struktur masalah
Penggunaan QPU	Berulang kali mengestimasi energi circuit berparameter di dalam loop optimisasi klasik	Hanya mengambil sampel bitstring. Tidak ada parameter circuit yang dilatih di QPU
Dari sampel ke solusi	Memilih bitstring terukur terbaik	Mendiagonalkan Hamiltonian relaxed di subruang hasil sampling pada komputer klasik dan melakukan rounding pada keadaan yang dihasilkan

Di sekeliling SQOA-QR, SQOA Solver menambahkan pemrosesan klasik. Preprocessing-nya menetapkan variabel yang nilai optimalnya bisa ditentukan sebelumnya dan merancang penugasan variabel ke qubit. Postprocessing-nya memperhalus solusi hasil rounding dengan pencarian lokal, yang bisa kamu matikan dengan postprocessing_level=0.

Benchmark

Disclaimer

Performa bisa bergantung pada instans masalah dan langkah pemrosesan selanjutnya. Dalam beberapa kasus, sampel klasik dan sampel hasil kuantum mungkin mencapai kualitas solusi akhir yang mirip setelah postprocessing yang setara. Karena itu, evaluasi harus mempertimbangkan seluruh alur kerja optimisasi.

Metrik benchmark berikut memberi gambaran umum tentang kualitas solusi, kompresi qubit, dan waktu eksekusi pada berbagai ukuran dan struktur masalah. Tabel ini memuat beberapa instans Maximum Independent Set dari Quantum Optimization Benchmarking Library (QOBLIB) dan dua instans MaxCut 3-regular. Kamu bisa memuat instans QOBLIB sebagai objek ommx.v1.Instance, beserta solusi optimalnya, dengan paket ommx-quantum-benchmarks.

Setiap instans dijalankan 10 kali pada prosesor IBM Heron r2. Number of qubits menghitung qubit yang benar-benar dipakai di hardware setelah preprocessing dan penyandian QRAC. Rasio kompresi bergantung pada instansnya. Approximation ratio (AR) melaporkan kualitas solusi terbaik yang ditemukan dalam 10 kali jalan:

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

dengan $C_{\textrm{best}}$ adalah nilai objektif terbaik yang ditemukan dan $C_{\textrm{opt}}$ adalah nilai objektif optimal yang diketahui. Semua instans adalah masalah maksimisasi dengan nilai optimal positif, jadi AR paling besar 100%, dan 100% pada kolom Approximation ratio menunjukkan solver menemukan solusi optimal. Total time adalah rata-rata gabungan waktu QPU dan CPU per jalan. QPU time adalah rata-rata pemakaian IBM Quantum Compute per jalan.

Instans	Jumlah variabel	Jumlah qubit	Approximation ratio	Total waktu (detik)	Waktu QPU (detik)
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

Mulai

Temukan informasi akses untuk Qiskit Function ini di Qiskit Functions Catalog.

Bagian ini menunjukkan cara autentikasi dan memuat function, serta cara menyiapkan masalah dalam format dictionary yang diterima SQOA Solver dengan memakai OptimizationProblem dari qiskit-addon-opt-mapper. Contoh-contoh berikutnya menjalankan function dan membaca hasilnya.

Autentikasi dan muat function

Pertama, lakukan autentikasi dengan API key IBM Quantum-mu. (Kode berikut mengasumsikan kamu sudah menyimpan akunmu di environment lokal.) Lalu buat catalog client seperti berikut:

# 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")

Siapkan input dengan qiskit-addon-opt-mapper

Panduan ini memodelkan masalah dengan kelas OptimizationProblem dari qiskit-addon-opt-mapper. SQOA Solver menerima masalah QUBO sebagai dictionary koefisien dalam format tuple-string yang dipakai oleh function optimisasi IBM, jadi setiap contoh di panduan ini mengikuti pola persiapan sisi klien yang sama:

1. Tulis model. Buat OptimizationProblem, tambahkan variabel keputusan biner, lalu atur objektif dan kendala apa pun.

2. Ubah ke QUBO. Ubah masalah dengan OptimizationProblemToQubo, yang menambahkan kendala apa pun ke objektif sebagai suku penalti dan mengembalikan masalah minimisasi tanpa kendala yang ekuivalen.

3. Ubah ke dictionary. Berikan QUBO ke fungsi helper to_problem_dict() yang didefinisikan di bagian berikutnya, lalu berikan hasilnya ke solver.run() sebagai problem, bersama variable_type="binary".

SQOA Solver selalu meminimalkan masalah berbentuk dictionary, yang sesuai dengan masalah minimisasi yang dikembalikan OptimizationProblemToQubo. Jadi, untuk masalah maksimisasi, objective_value yang dikembalikan adalah negatif dari objektif aslinya. Untuk membaca hasil dalam bentuk masalah aslinya, evaluasi penugasan yang dikembalikan dengan OptimizationProblem, seperti yang ditunjukkan contoh. Untuk detail format dictionary, lihat Accepted problem formats di referensi API.

# %pip install qiskit-addon-opt-mapper

Definisikan fungsi helper berikut sekali dan pakai ulang di setiap contoh. Fungsi ini mengubah QUBO yang dikembalikan OptimizationProblemToQubo ke format dictionary. Key-nya memakai indeks variabel dari QUBO, jadi key solusi x_0, x_1, dan seterusnya pada hasil sesuai dengan indeks tersebut. Setiap variabel mendapat entri linear, bahkan dengan koefisien nol, supaya solusi yang dikembalikan mencakup semua variabel.

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

Contoh 1: MaxCut pada graf 3-regular

Banyak masalah graf, seperti MaxCut, bersifat NP-hard dan menjadi kandidat alami untuk optimisasi kuantum. Instal networkx sebagai dependensi tambahan untuk menjalankan contoh ini:

# %pip install networkx

1. Tulis model

Tetapkan variabel biner $x_v \in \{0, 1\}$ untuk setiap simpul graf $G = (V, E)$ untuk menunjukkan sisi potongannya. Sebuah sisi (edge) terpotong ketika kedua ujungnya berada di sisi yang berbeda, sehingga ukuran potongan adalah:

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

Objektif ini sudah berupa QUBO tanpa kendala, jadi OptimizationProblemToQubo hanya mengubah maksimisasi menjadi minimisasi yang ekuivalen dan membiarkan variabelnya tidak berubah. Kelas aplikasi Maxcut di qiskit_addon_opt_mapper.applications membangun model yang sama dengan 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. Jalankan solver

Ubah model menjadi QUBO lalu menjadi dictionary, dan kirimkan. problem dan variable_type wajib diisi. backend_name bersifat opsional. Saat dihilangkan atau bernilai None, function memilih QPU operasional yang paling tidak sibuk yang tersedia untuk instance-mu.

Dictionary options menerima shots, seed, session, postprocessing_level, dan job_tags. Untuk deskripsi dan nilai default, lihat referensi 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. Ambil hasil

job.result() mengembalikan dictionary dengan empat key:

• solution adalah penugasan variabel lengkap, dengan key x_i, di mana i adalah indeks variabel (misalnya, x_3).

• objective_value dan feasible adalah nilai objektif dan kelayakan dari penugasan tersebut, yang dievaluasi pada dictionary yang dikirim.

• metadata berisi solver_info dan resource_usage.

Karena QUBO adalah bentuk minimisasi dari MaxCut, objective_value adalah negatif dari ukuran potongan. Evaluasi penugasan pada OptimizationProblem asli untuk membaca ukuran potongan secara langsung.

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. Periksa pemakaian resource

result["metadata"]["resource_usage"] melaporkan waktu yang dihabiskan di setiap fase eksekusi. Fase selain RUNNING: EXECUTING_QPU melaporkan CPU_TIME, yaitu wall-clock time fase tersebut dalam detik, jika tersedia.

Fase RUNNING: EXECUTING_QPU melaporkan QPU_TIME, yaitu pemakaian QPU dari semua job Quantum Compute pada proses tersebut, jika pemakaian akhir tersedia untuk setiap job. Untuk detailnya, lihat referensi 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

Contoh 2: Ubah masalah berkendala menjadi QUBO

SQOA Solver menerima masalah tanpa kendala. Contoh ini menunjukkan cara mengubah masalah berkendala menjadi QUBO dengan OptimizationProblemToQubo dan memetakan hasilnya kembali ke variabel masalah asli.

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 menambahkan kendala ke objektif sebagai suku penalti dan mengubah masalah menjadi minimisasi. Bobot penalti yang tepat bergantung pada masalahnya.

Setelah dijalankan, interpret() memetakan penugasan QUBO kembali ke variabel masalah asli.

Evaluasi objektif dan kelayakan pada masalah asli. Untuk masalah berbentuk dictionary, field feasible pada hasil hanya merujuk pada domain variabel, karena dictionary tidak punya kendala.

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.]

Contoh 3: Kirim instance OMMX

SQOA Solver juga menerima ommx.v1.Instance dari SDK OMMX, yang menyimpan nama variabel, subskrip, dan metadata konversi bersama masalahnya. Dibandingkan dengan dictionary, input OMMX punya keunggulan berikut:

• Hasilnya juga memuat ommx.v1.Solution kanonik di solver_info["ommx_solution"].

• objective_value dievaluasi sesuai makna instance-nya, jadi objektif masalah maksimisasi tidak dinegasikan.

• Untuk instance yang diubah di tempat dengan Instance.to_qubo(), feasible dievaluasi terhadap kendala aslinya.

Contoh ini membangun model MaxCut dari Contoh 1 dengan JijModeling, sebuah modeler optimisasi matematika yang mengompilasi model menjadi instance OMMX. Instal JijModeling, yang juga menginstal paket ommx:

# %pip install "jijmodeling~=2.8.0"

SQOA Solver menukar data OMMX sebagai string Base64 berpadding standar. Definisikan fungsi helper berikut untuk konversi ini:

• to_problem_payload() melakukan serialisasi ommx.v1.Instance menjadi string yang kamu berikan sebagai problem.

• to_ommx_solution() mendekode ommx.v1.Solution kanonik dari hasilnya.

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. Tulis model dengan JijModeling

Formulasi spin yang biasa untuk MaxCut pada graf $G = (V, E)$ menetapkan $s_v \in \{-1, +1\}$ ke setiap simpul. Sebuah sisi terpotong ketika $s_u s_v = -1$, sehingga ukuran potongan adalah:

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

JijModeling tidak menyediakan variabel keputusan spin bawaan, dan SQOA Solver menerima variabel QUBO biner. Karena itu, deklarasikan $b_v \in \{0, 1\}$ dan definisikan ekspresi bernilai spin $s_v = 1 - 2b_v$ di dalam model. Dengan ekspresi ini, objektif tetap dalam bentuk spin standar, dan instance terkompilasi tetap berupa QUBO biner.

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)

Kalau kamu menampilkan maxcut_model di notebook, akan muncul formulasi berikut:

$$\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. Kompilasi instance dan jalankan solver

Ikat graf dari Contoh 1 untuk mengompilasi ommx.v1.Instance, lalu kirimkan dengan variable_type="binary". Instance OMMX selalu dikirim sebagai masalah biner.

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. Ambil hasil

Untuk input OMMX, objective_value adalah ukuran potongan, dan to_ommx_solution() mendekode solusi kanonik sehingga kamu bisa membaca penugasan berdasarkan nama variabel.

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]

Dapatkan dukungan

Untuk dukungan, kirim email ke info@j-ij.com.

Langkah selanjutnya

Rekomendasi

• Minta uji coba gratis SQOA Solver dengan mengisi formulir ini.
• Kunjungi referensi API untuk Qiskit Function ini.
• Coba contoh end-to-end di tutorial masalah maximum independent set.
• Pelajari cara memodelkan masalah optimisasi dengan qiskit-addon-opt-mapper.
• Pelajari cara memodelkan dan menukar masalah optimisasi dengan JijModeling dan OMMX.
• Baca makalah SQOA-QR [1] untuk mempelajari lebih lanjut kerangka SQOA.

Referensi

[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