SQOA Solver - Qiskit Function oleh JIJ

Lihat rujukan API.

nota

Qiskit Functions ialah ciri eksperimen yang hanya tersedia kepada pengguna IBM Quantum® Premium Plan, Flex Plan dan On-Prem (melalui IBM Quantum Platform API) Plan. Ia berstatus keluaran pratonton dan tertakluk kepada perubahan.

Gambaran keseluruhan

Dengan SQOA Solver oleh JIJ, anda boleh menyelesaikan masalah pengoptimuman kombinatorial yang besar pada komputer kuantum IBM®. Penyelesai ini berdasarkan Sampling-based Quantum Optimization Algorithm with Quantum Relaxation (SQOA-QR) [1]. Berbeza daripada algoritma kuantum yang menggunakan pemetaan satu-ke-satu antara pemboleh ubah keputusan klasik dengan qubit, SQOA Solver boleh mengendalikan masalah pengoptimuman yang mempunyai lebih banyak pemboleh ubah daripada bilangan qubit yang tersedia pada peranti kuantum semasa. Reka bentuknya yang berasaskan pensampelan juga menjadikannya kurang sensitif terhadap hingar fizikal pada perkakasan kuantum semasa. Bersama-sama, ciri-ciri ini menjadikan SQOA Solver sangat sesuai untuk masalah pengoptimuman pada peringkat pengkomputeran kuantum ini.

Penyelesai ini mengendalikan masalah Quadratic Unconstrained Binary Optimization (QUBO) yang diberikan sebagai formulasi matematik klasik, dan ia memetakan formulasi klasik itu secara automatik ke dalam persekitaran kuantum. Anda juga boleh menukar masalah berkekangan kepada masalah tanpa kekangan dengan menggunakan kaedah penalti.

Bahagian berikut menerangkan aliran kerja penyelesai, keputusan penanda aras, dan contoh hujung-ke-hujung yang memodelkan masalah dengan qiskit-addon-opt-mapper dan, secara pilihan, Open Mathematical prograMming eXchange (OMMX). OMMX ialah format data terbuka dan SDK yang memudahkan pertukaran masalah pengoptimuman antara alat perisian.

Perihalan

SQOA Solver melaksanakan Sampling-based Quantum Optimization Algorithm with Quantum Relaxation (SQOA-QR) dan mengelilinginya dengan prapemprosesan dan pascapemprosesan klasik. Bahagian ini menerangkan rangka kerja SQOA dan perbezaannya daripada Quantum Approximate Optimization Algorithm (QAOA).

Rajah berikut menunjukkan skema aliran kerja SQOA Solver.

Rangka kerja SQOA

SQOA ialah rangka kerja berasaskan pensampelan untuk pengoptimuman kombinatorial [1]. Ia menggabungkan dua teknik: Quantum Random Access Optimization (QRAO) [2], yang mengekod masalah dalam pelonggaran kuantum, dan sample-based quantum diagonalization (SQD) [3], yang juga dikenali sebagai quantum-selected configuration interaction (QSCI) [4], yang menggunakan komputer kuantum hanya untuk mensampel rentetan bit dan mencari keadaan bertenaga rendah pada komputer klasik. SQOA ialah rangka kerja dalam erti kata ia menetapkan gabungan ini tetapi menyerahkan butirannya kepada setiap pelaksanaan, seperti cara pemboleh ubah ditugaskan kepada qubit dan litar yang manakah menjana sampel.

• Pelonggaran kuantum dengan QRAO. QAOA dan pendekatan berasaskan Ising yang lain mewakili setiap pemboleh ubah binari dengan operator $Z$ bagi qubitnya. QRAO juga menggunakan operator $X$ dan $Y$. Dengan (3,1) quantum random access code (QRAC), sehingga tiga pemboleh ubah binari berkongsi satu qubit, dan setiap pemboleh ubah diwakili oleh operator Pauli yang berbeza.

  QUBO kemudian menjadi Hamiltonian terlonggar yang memerlukan lebih sedikit qubit daripada Hamiltonian Ising. Pemboleh ubah yang berinteraksi dalam QUBO mesti diletakkan pada qubit yang berbeza. Jika mereka berkongsi satu qubit, hasil darab operator Pauli mereka akan terturun kepada satu operator pada qubit itu (contohnya, $XY = iZ$), dan Hamiltonian terlonggar tidak lagi mewakili interaksi mereka.

  Oleh itu, penugasan pemboleh ubah kepada qubit menentukan bilangan qubit dan kualiti pelonggaran, dan SQOA Solver mereka bentuk penugasan ini dalam prapemprosesannya.

• Sample-based quantum diagonalization (SQD). Komputer kuantum mula-mula menyediakan keadaan kuantum yang bertindih dengan keadaan bertenaga rendah bagi Hamiltonian terlonggar dan kemudian mensampel rentetan bit daripadanya. Komputer klasik memproyeksikan Hamiltonian terlonggar ke atas subruang yang dirangkumi oleh rentetan bit yang disampel dan mendiagonalkannya untuk menganggar keadaan asas.

  Oleh sebab Hamiltonian terlonggar adalah tidak pepenjuru, pendiagonalan menggabungkan rentetan bit yang disampel menjadi superposisi. Dengan Hamiltonian Ising pepenjuru, setiap rentetan bit sudah pun merupakan keadaan eigen, dan pendiagonalan hanya akan memilih sampel terbaik. Pendekatan yang sama telah digunakan pada masalah berskala besar dalam kimia kuantum.

Keadaan asas hampiran yang diperoleh melalui SQD tidak sepadan secara langsung dengan penyelesaian klasik bagi masalah asal, jadi penyelesaian klasik mesti dinyahkod daripadanya. Oleh sebab keadaan ini dikira pada komputer klasik, penyahkodan yang dipanggil pembundaran ialah pascapemprosesan klasik. SQOA Solver menggunakan teknik penyahkodan yang direka untuk memperoleh penyelesaian klasik yang lebih baik secara heuristik.

Jadual berikut membandingkan SQOA dengan QAOA, pendekatan variasi yang lazim untuk kelas masalah yang sama.

	QAOA	SQOA
Qubit untuk $n$ pemboleh ubah binari	$n$	Satu qubit memuatkan sehingga tiga pemboleh ubah. Bilangan sebenar bergantung pada struktur masalah
Penggunaan QPU	Menganggar tenaga litar berparameter berulang kali dalam gelung pengoptimuman klasik	Hanya mensampel rentetan bit. Tiada parameter litar dilatih pada QPU
Daripada sampel kepada penyelesaian	Memilih rentetan bit terukur yang terbaik	Mendiagonalkan Hamiltonian terlonggar dalam subruang yang disampel pada komputer klasik dan membundarkan keadaan yang terhasil

Di sekeliling SQOA-QR, SQOA Solver menambah pemprosesan klasik. Prapemprosesannya menetapkan pemboleh ubah yang nilai optimumnya boleh ditentukan lebih awal dan mereka bentuk penugasan pemboleh ubah kepada qubit. Pascapemprosesannya memperhalus penyelesaian yang dibundarkan dengan carian tempatan, yang boleh anda matikan dengan postprocessing_level=0.

Penanda aras

Penafian

Prestasi boleh bergantung pada kedua-dua contoh masalah dan langkah pemprosesan seterusnya. Dalam sesetengah kes, sampel klasik dan sampel yang dijana secara kuantum mungkin mencapai kualiti penyelesaian akhir yang serupa selepas pascapemprosesan yang setara. Penilaian oleh itu harus mengambil kira keseluruhan aliran kerja pengoptimuman.

Metrik penanda aras berikut memberikan petunjuk umum tentang kualiti penyelesaian, pemampatan qubit dan masa pelaksanaan merentasi saiz dan struktur masalah terpilih. Jadual ini menyenaraikan pilihan contoh Maximum Independent Set daripada Quantum Optimization Benchmarking Library (QOBLIB) dan dua contoh MaxCut 3-sekata. Anda boleh memuatkan contoh QOBLIB sebagai objek ommx.v1.Instance, bersama penyelesaian optimumnya, dengan menggunakan pakej ommx-quantum-benchmarks.

Setiap contoh dijalankan 10 kali pada pemproses IBM Heron r2. Number of qubits mengira qubit yang sebenarnya digunakan pada perkakasan selepas prapemprosesan dan pengekodan QRAC. Nisbah pemampatan bergantung pada contoh. Approximation ratio (AR) melaporkan kualiti penyelesaian terbaik yang ditemui sepanjang 10 larian:

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

dengan $C_{\textrm{best}}$ ialah nilai objektif terbaik yang ditemui dan $C_{\textrm{opt}}$ ialah nilai objektif optimum yang diketahui. Semua contoh ialah masalah pemaksimuman dengan nilai optimum positif, jadi AR paling tinggi 100%, dan 100% dalam lajur Approximation ratio menunjukkan bahawa penyelesai menemui penyelesaian optimum. Total time ialah purata gabungan masa QPU dan CPU bagi setiap larian. QPU time ialah purata penggunaan IBM Quantum Compute bagi setiap larian.

Contoh	Bilangan pemboleh ubah	Bilangan qubit	Nisbah penghampiran	Jumlah masa (saat)	Masa QPU (saat)
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

Bermula

Dapatkan maklumat akses untuk Qiskit Function ini dalam Qiskit Functions Catalog.

Bahagian ini menunjukkan cara mengesahkan dan memuatkan fungsi, serta cara menyediakan masalah dalam format kamus yang diterima oleh SQOA Solver dengan menggunakan OptimizationProblem daripada qiskit-addon-opt-mapper. Contoh-contoh seterusnya menjalankan fungsi dan membaca hasilnya.

Sahkan dan muatkan fungsi

Mula-mula, sahkan dengan kunci API IBM Quantum anda. (Kod berikut mengandaikan anda sudah menyimpan akaun anda ke persekitaran tempatan anda.) Kemudian, cipta klien katalog 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")

Sediakan input dengan qiskit-addon-opt-mapper

Panduan ini memodelkan masalah dengan kelas OptimizationProblem daripada qiskit-addon-opt-mapper. SQOA Solver menerima masalah QUBO sebagai kamus pekali dalam format tuple-rentetan yang digunakan oleh fungsi pengoptimuman IBM, jadi setiap contoh dalam panduan ini mengikuti corak penyediaan sisi klien yang sama:

1. Tulis model. Cipta OptimizationProblem, tambah pemboleh ubah keputusan binari, dan tetapkan objektif serta sebarang kekangan.

2. Tukar kepada QUBO. Tukar masalah dengan OptimizationProblemToQubo, yang menambah sebarang kekangan kepada objektif sebagai sebutan penalti dan mengembalikan masalah peminimuman tanpa kekangan yang setara.

3. Tukar kepada kamus. Hantar QUBO kepada fungsi pembantu to_problem_dict() yang ditakrifkan dalam bahagian seterusnya, dan hantar hasilnya kepada solver.run() sebagai problem, bersama variable_type="binary".

SQOA Solver sentiasa meminimumkan masalah kamus, yang sepadan dengan masalah peminimuman yang dikembalikan oleh OptimizationProblemToQubo. Oleh itu, bagi masalah pemaksimuman, objective_value yang dikembalikan ialah negatif bagi objektif asal. Untuk membaca hasil dari segi masalah asal, nilaikan penugasan yang dikembalikan dengan OptimizationProblem, seperti yang ditunjukkan oleh contoh. Untuk butiran format kamus, lihat Accepted problem formats dalam rujukan API.

# %pip install qiskit-addon-opt-mapper

Takrifkan fungsi pembantu berikut sekali sahaja dan gunakannya semula dalam setiap contoh. Ia menukar QUBO yang dikembalikan oleh OptimizationProblemToQubo kepada format kamus. Kunci menggunakan indeks pemboleh ubah QUBO, jadi kunci penyelesaian x_0, x_1 dan seterusnya dalam hasil sepadan dengan indeks tersebut. Setiap pemboleh ubah menerima entri linear, walaupun dengan pekali sifar, supaya penyelesaian yang dikembalikan meliputi semua pemboleh ubah.

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-sekata

Banyak masalah graf, seperti MaxCut, ialah NP-hard dan merupakan calon semula jadi untuk pengoptimuman kuantum. Pasang networkx sebagai kebergantungan tambahan untuk menjalankan contoh ini:

# %pip install networkx

1. Tulis model

Tugaskan pemboleh ubah binari $x_v \in \{0, 1\}$ kepada setiap bucu graf $G = (V, E)$ untuk menunjukkan sisinya dalam potongan. Sesuatu tepi dipotong apabila hujung-hujungnya berada pada sisi yang berbeza, jadi saiz potongan ialah:

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

Objektif ini sudah pun QUBO tanpa kekangan, jadi OptimizationProblemToQubo hanya menukar pemaksimuman kepada peminimuman yang setara dan mengekalkan pemboleh ubah tanpa perubahan. Kelas aplikasi Maxcut dalam qiskit_addon_opt_mapper.applications membina 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 penyelesai

Tukar model kepada QUBO dan kemudian kepada kamus, lalu serahkannya. problem dan variable_type diperlukan. backend_name adalah pilihan. Apabila ia ditinggalkan atau None, fungsi memilih QPU operasi yang paling kurang sibuk yang tersedia kepada instans anda.

Kamus options menerima shots, seed, session, postprocessing_level dan job_tags. Untuk perihalan dan nilai lalai, lihat rujukan 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. Dapatkan hasil

job.result() mengembalikan kamus dengan empat kunci:

• solution ialah penugasan pemboleh ubah yang lengkap, dengan kunci x_i, di mana i ialah indeks pemboleh ubah (contohnya, x_3).

• objective_value dan feasible ialah objektif dan kebolehlaksanaan bagi penugasan itu, dinilai pada kamus yang diserahkan.

• metadata mengandungi solver_info dan resource_usage.

Oleh sebab QUBO ialah bentuk peminimuman bagi MaxCut, objective_value ialah negatif bagi saiz potongan. Nilaikan penugasan pada OptimizationProblem asal untuk membaca saiz 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. Semak penggunaan sumber

result["metadata"]["resource_usage"] melaporkan masa yang dihabiskan dalam setiap fasa pelaksanaan. Fasa selain RUNNING: EXECUTING_QPU melaporkan CPU_TIME, iaitu masa jam dinding fasa dalam saat, apabila ia tersedia.

Fasa RUNNING: EXECUTING_QPU melaporkan QPU_TIME, iaitu penggunaan QPU bagi semua tugasan Quantum Compute dalam larian, jika penggunaan akhir tersedia untuk setiap tugasan. Untuk butiran, lihat rujukan 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: Tukar masalah berkekangan kepada QUBO

SQOA Solver menerima masalah tanpa kekangan. Contoh ini menunjukkan cara menukar masalah berkekangan kepada QUBO dengan OptimizationProblemToQubo dan memetakan hasilnya kembali kepada pemboleh ubah masalah asal.

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 menambah kekangan kepada objektif sebagai sebutan penalti dan menukar masalah kepada peminimuman. Pemberat penalti yang sesuai bergantung pada masalah.

Selepas larian, interpret() memetakan penugasan QUBO kembali kepada pemboleh ubah masalah asal.

Nilaikan objektif dan kebolehlaksanaan pada masalah asal. Bagi masalah kamus, medan feasible dalam hasil hanya merujuk kepada domain pemboleh ubah, kerana kamus tidak mempunyai kekangan.

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: Serahkan instans OMMX

SQOA Solver juga menerima ommx.v1.Instance daripada SDK OMMX, yang menyimpan nama pemboleh ubah, subskrip dan metadata penukaran bersama masalah. Berbanding kamus, input OMMX mempunyai kelebihan berikut:

• Hasilnya juga mengandungi ommx.v1.Solution kanonik dalam solver_info["ommx_solution"].

• objective_value dinilai mengikut erti instans, jadi objektif bagi masalah pemaksimuman tidak dinegatifkan.

• Bagi instans yang ditukar di tempat dengan Instance.to_qubo(), feasible dinilai berdasarkan kekangan asal.

Contoh ini membina model MaxCut daripada Contoh 1 dengan JijModeling, pemodel pengoptimuman matematik yang mengkompil model menjadi instans OMMX. Pasang JijModeling, yang juga memasang pakej ommx:

# %pip install "jijmodeling~=2.8.0"

SQOA Solver menukar data OMMX sebagai rentetan Base64 berlapik piawai. Takrifkan fungsi pembantu berikut untuk penukaran ini:

• to_problem_payload() menyirikan ommx.v1.Instance menjadi rentetan yang anda hantar sebagai problem.

• to_ommx_solution() menyahkod ommx.v1.Solution kanonik daripada hasil.

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 biasa bagi MaxCut pada graf $G = (V, E)$ menugaskan $s_v \in \{-1, +1\}$ kepada setiap bucu. Sesuatu tepi dipotong apabila $s_u s_v = -1$, jadi saiz potongan ialah:

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

JijModeling tidak menyediakan pemboleh ubah keputusan spin asli, dan SQOA Solver menerima pemboleh ubah QUBO binari. Oleh itu, isytiharkan $b_v \in \{0, 1\}$ dan takrifkan ungkapan bernilai spin $s_v = 1 - 2b_v$ di dalam model. Dengan ungkapan ini, objektif kekal dalam bentuk spin piawai, dan instans yang dikompil kekal sebagai QUBO binari.

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)

Jika anda memaparkan maxcut_model dalam buku nota, ia menunjukkan 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. Kompil instans dan jalankan penyelesai

Ikat graf daripada Contoh 1 untuk mengkompil ommx.v1.Instance, dan serahkannya dengan variable_type="binary". Instans OMMX sentiasa diserahkan sebagai masalah binari.

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

Bagi input OMMX, objective_value ialah saiz potongan, dan to_ommx_solution() menyahkod penyelesaian kanonik supaya anda boleh membaca penugasan mengikut nama pemboleh ubah.

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 sokongan

Untuk sokongan, e-mel info@j-ij.com.

Langkah seterusnya

Cadangan

• Mohon percubaan percuma SQOA Solver dengan melengkapkan borang ini.
• Lawati rujukan API untuk Qiskit Function ini.
• Cuba contoh hujung-ke-hujung dalam tutorial masalah set bebas maksimum.
• Ketahui cara memodelkan masalah pengoptimuman dengan qiskit-addon-opt-mapper.
• Ketahui cara memodel dan menukar masalah pengoptimuman dengan JijModeling dan OMMX.
• Baca kertas SQOA-QR [1] untuk mengetahui lebih lanjut tentang rangka kerja SQOA.

Rujukan

[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