Optimization Solver: A Qiskit Function by Q-CTRL Fire Opal

nota

Fungsi Qiskit adalah ciri eksperimental yang hanya tersedia untuk pengguna Pelan Premium IBM Quantum®, Pelan Flex, dan Pelan On-Prem (melalui API Platform IBM Quantum). Ia berada dalam status keluaran pratonton dan tertakluk kepada perubahan.

Gambaran keseluruhan

Dengan Fire Opal Optimization Solver, anda boleh menyelesaikan masalah pengoptimuman skala utiliti pada perkakasan kuantum tanpa memerlukan kepakaran kuantum. Cukup masukkan definisi masalah peringkat tinggi, dan Solver akan menguruskan selebihnya. Keseluruhan aliran kerja ini peka hingar dan memanfaatkan Pengurusan Prestasi Fire Opal di sebaliknya. Solver secara konsisten memberikan penyelesaian tepat untuk masalah yang mencabar secara klasik, walaupun pada skala penuh peranti pada QPU IBM® yang terbesar.

Solver fleksibel dan boleh digunakan untuk menyelesaikan masalah pengoptimuman kombinatorial yang ditakrifkan sebagai fungsi objektif atau graf arbitrari. Masalah tidak perlu dipetakan ke topologi peranti. Masalah tanpa kekangan dan dengan kekangan boleh diselesaikan, dengan syarat kekangan boleh diformulasikan sebagai terma penalti. Contoh-contoh dalam panduan ini menunjukkan cara menyelesaikan masalah pengoptimuman skala utiliti tanpa kekangan dan dengan kekangan menggunakan jenis input Solver yang berbeza. Contoh pertama melibatkan masalah Max-Cut yang ditakrifkan pada graf 3-Biasa 156 nod, manakala contoh kedua menangani masalah Penutup Bucu Minimum 50 nod yang ditakrifkan oleh fungsi kos.

Untuk mendapatkan akses kepada Optimization Solver, hubungi Q-CTRL.

Penerangan fungsi

Solver mengoptimumkan dan mengautomatikkan keseluruhan algoritma sepenuhnya, dari penindasan ralat pada peringkat perkakasan hingga pemetaan masalah yang cekap dan pengoptimuman klasik gelung tertutup. Di sebalik tabir, saluran Solver mengurangkan ralat pada setiap peringkat, membolehkan peningkatan prestasi yang diperlukan untuk menskalakan secara bermakna. Aliran kerja asas ini terinspirasi oleh Quantum Approximate Optimization Algorithm (QAOA), yang merupakan algoritma hibrid kuantum-klasik. Untuk ringkasan terperinci aliran kerja Optimization Solver yang penuh, rujuk manuskrip yang diterbitkan.

Untuk menyelesaikan masalah umum dengan Optimization Solver:

1. Takrifkan masalah anda sebagai fungsi objektif, graf, atau rantai spin SparsePauliOp.
2. Sambung ke fungsi melalui Katalog Fungsi Qiskit.
3. Jalankan masalah dengan Solver dan dapatkan semula keputusan.

Input dan output

Input

Nama	Jenis	Penerangan	Diperlukan	Lalai	Contoh
problem	str atau SparsePauliOp	Salah satu representasi yang disenaraikan di bawah "Format masalah yang diterima"	Ya	T/A	Poly(2.0*n[0]*n[1] + 2.0*n[0]*n[2] - 3.13520241298341*n[0] + 2.0*n[1]*n[2] - 3.14469748506794*n[1] - 3.18897660121566*n[2] + 6.0, n[0], n[1], n[2], domain='RR')
problem_type	str	Nama kelas masalah; hanya digunakan untuk definisi masalah graf dan rantai spin, yang terhad kepada "maxcut" atau "spin_chain"; tidak diperlukan untuk definisi masalah fungsi objektif arbitrari	Tidak	None	"maxcut"
backend_name	str	Nama backend yang hendak digunakan	Tidak	Backend paling kurang sibuk yang boleh diakses oleh instans anda	"ibm_fez"
options	dict	Pilihan input, termasuk yang berikut: (Pilihan) session_id: str; tingkah laku lalai mencipta Sesi baharu	Tidak	None	{"session_id": "cw2q70c79ws0008z6g4g"}

Format masalah yang diterima:

• Representasi ungkapan polinomial bagi fungsi objektif. Sebaik-baiknya dibuat dalam Python dengan objek SymPy Poly sedia ada dan diformat menjadi rentetan menggunakan sympy.srepr.
• Representasi graf bagi jenis masalah tertentu. Graf perlu dibuat menggunakan pustaka networkx dalam Python. Ia kemudian ditukar kepada rentetan menggunakan fungsi networkx [nx.readwrite.json_graph.adjacency_data](http://nx.readwrite.json_graph.adjacency_data.).
• Representasi rantai spin bagi masalah tertentu. Rantai spin perlu direpresentasikan sebagai objek SparsePauliOp; lihat dokumentasi untuk maklumat lanjut.

Backend yang disokong: Jalankan kod berikut untuk melihat senarai backend yang disokong masa ini. Jika peranti anda tidak disenaraikan, hubungi Q-CTRL untuk menambah sokongan.

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

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

service.backends()

[<IBMBackend('ibm_fez')>,
 <IBMBackend('ibm_brisbane')>,
 <IBMBackend('ibm_pittsburgh')>,
 <IBMBackend('ibm_kingston')>,
 <IBMBackend('ibm_torino')>,
 <IBMBackend('ibm_marrakesh')>]

Pilihan:

Nama	Jenis	Penerangan	Lalai
session_id	str	ID sesi Qiskit Runtime sedia ada	"cw4r3je6f0t010870y3g"
job_tags	list[str]	Senarai tag kerja	[]

Output

Nama	Jenis	Penerangan	Contoh
result	dict[str, Any]	Penyelesaian dan metadata yang disenaraikan di bawah "Kandungan kamus keputusan"	{'solution_bitstring_cost': 3.0, 'final_bitstring_distribution': {'000001': 100, '000011': 2}, 'iteration_count': 3, 'solution_bitstring': '000001', 'variables_to_bitstring_index_map': {n[1]': 5, 'n[2]': 4, 'n[3]': 3, 'n[4]': 2, 'n[5]': 1}, 'best_parameters': [0.19628831763697097, -1.047052334523102], 'warnings': []}

Kandungan kamus keputusan:

Nama	Jenis	Penerangan
solution_bitstring_cost	float	Kos minimum terbaik merentasi semua iterasi
final_bitstring_distribution	CountsDict	Kamus kiraan bitstring yang berkaitan dengan kos minimum
solution_bitstring	str	Bitstring dengan kos terbaik dalam taburan akhir
iteration_count	int	Jumlah bilangan iterasi QAOA yang dilakukan oleh Solver
variables_to_bitstring_index_map	float	Pemetaan dari pemboleh ubah ke bit yang bersamaan dalam bitstring
best_parameters	list[float]	Parameter beta dan gamma yang dioptimumkan merentasi semua iterasi
warnings	list[str]	Amaran yang dihasilkan semasa mengkompil atau menjalankan QAOA (lalai kepada None)

Penanda aras

Keputusan penanda aras yang diterbitkan menunjukkan bahawa Solver berjaya menyelesaikan masalah dengan lebih 120 qubit, malah mengatasi keputusan yang diterbitkan sebelumnya pada peranti anil kuantum dan ion perangkap. Metrik penanda aras berikut memberikan petunjuk kasar tentang ketepatan dan penskalaan jenis masalah berdasarkan beberapa contoh. Metrik sebenar mungkin berbeza berdasarkan pelbagai ciri masalah, seperti bilangan terma dalam fungsi objektif (ketumpatan) dan lokaliti, bilangan pemboleh ubah, dan tertib polinomial.

"Bilangan qubit" yang ditunjukkan bukan had keras tetapi mewakili ambang kasar di mana anda boleh mengharapkan ketepatan penyelesaian yang sangat konsisten. Saiz masalah yang lebih besar telah berjaya diselesaikan, dan ujian melebihi had ini digalakkan.

Kesambungan qubit arbitrari disokong merentasi semua jenis masalah.

Jenis masalah	Bilangan qubit	Contoh	Ketepatan	Jumlah masa (s)	Penggunaan runtime (s)	Bilangan iterasi
Masalah kuadratik bersambung jarang	156	Max-Cut 3-regular	100%	1764	293	16
Pengoptimuman binari tertib tinggi	156	Model kaca spin Ising	100%	1461	272	16
Masalah kuadratik bersambung padat	50	Max-Cut bersambung penuh	100%	1758	268	12
Masalah dengan kekangan dan terma penalti	50	Penutup Bucu Minimum Berwajaran dengan ketumpatan tepi 8%	100%	1074	215	10

Mulakan

Pertama, sahkan menggunakan kunci API IBM Quantum anda. Kemudian, pilih Fungsi Qiskit seperti berikut. (Petikan kod ini menganggap anda sudah menyimpan akaun anda ke persekitaran tempatan.)

from qiskit_ibm_catalog import QiskitFunctionsCatalog

catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")

# Access Function
solver = catalog.load("q-ctrl/optimization-solver")

Contoh: Pengoptimuman tanpa kekangan

Jalankan masalah maximum cut (Max-Cut). Contoh berikut menunjukkan keupayaan Solver pada masalah Max-Cut graf 3-regular tidak berwajaran 156 nod, tetapi anda juga boleh menyelesaikan masalah graf berwajaran. Selain qiskit-ibm-catalog, anda juga akan menggunakan pakej berikut untuk menjalankan contoh ini: networkx dan numpy. Anda boleh memasang pakej ini dengan menyahkomenter sel berikut jika anda menjalankan contoh ini dalam notebook menggunakan kernel IPython.

# %pip install networkx numpy

1. Takrifkan masalah

Anda boleh menjalankan masalah Max-Cut dengan mentakrifkan masalah graf dan menentukan problem_type='maxcut'.

import networkx as nx
import numpy as np

# Generate a random graph with 156 nodes
maxcut_graph = nx.random_regular_graph(d=3, n=156, seed=8)

# Optionally, visualize the graph
nx.draw_networkx(
    maxcut_graph, nx.kamada_kawai_layout(maxcut_graph), node_size=100
)

Solver menerima rentetan sebagai input definisi masalah.

# Convert graph to string
problem_as_str = nx.readwrite.json_graph.adjacency_data(maxcut_graph)

2. Jalankan masalah

Apabila menggunakan kaedah input berasaskan graf, tentukan jenis masalah.

# This cell is hidden from users
from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
backend_name = service.least_busy(n_qubits=156).name

# Solve the problem
maxcut_job = solver.run(
    problem=problem_as_str,
    problem_type="maxcut",
    backend_name=backend_name,  # E.g. "ibm_fez"
)

Semak status beban kerja Fungsi Qiskit anda atau dapatkan semula keputusan seperti berikut:

# Get job status
print(maxcut_job.status())

QUEUED

3. Dapatkan semula keputusan

Dapatkan semula nilai potongan optimum dari kamus keputusan.

nota

Pemetaan pemboleh ubah ke bitstring mungkin telah berubah. Kamus output mengandungi subdiksi variables_to_bitstring_index_map, yang membantu mengesahkan urutan.

# Poll for results
maxcut_result = maxcut_job.result()

# Take the absolute value of the solution since the cost function is minimized
qctrl_maxcut = abs(maxcut_result["solution_bitstring_cost"])

# Print the optimal cut value found by the Optimization Solver
print(f"Optimal cut value: {qctrl_maxcut}")

Optimal cut value: 209.0

Anda boleh mengesahkan ketepatan keputusan dengan menyelesaikan masalah secara klasik menggunakan penyelesai sumber terbuka seperti PuLP jika graf tidak bersambung padat. Masalah berketumpatan tinggi mungkin memerlukan penyelesai klasik lanjutan untuk mengesahkan penyelesaian.

Contoh: Pengoptimuman dengan kekangan

Contoh Max-Cut sebelumnya adalah masalah pengoptimuman binari kuadratik tanpa kekangan yang biasa. Optimization Solver Q-CTRL boleh digunakan untuk pelbagai jenis masalah, termasuk pengoptimuman dengan kekangan. Anda boleh menyelesaikan jenis masalah arbitrari dengan memasukkan definisi masalah yang direpresentasikan sebagai polinomial di mana kekangan dimodelkan sebagai terma penalti.

Contoh berikut menunjukkan cara membina fungsi kos untuk masalah pengoptimuman dengan kekangan, minimum vertex cover (MVC). Selain pakej qiskit-ibm-catalog dan qiskit, anda juga akan menggunakan pakej berikut untuk menjalankan contoh ini: numpy, networkx, dan sympy. Anda boleh memasang pakej ini dengan menyahkomenter sel berikut jika anda menjalankan contoh ini dalam notebook menggunakan kernel IPython.

# %pip install numpy networkx sympy

1. Takrifkan masalah

Takrifkan masalah MVC rawak dengan menjana graf dengan nod berwajaran rawak.

import networkx as nx
from sympy import symbols, Poly, srepr

# To change the weights, change the seed to any integer.
rng_seed = 18
_rng = np.random.default_rng(rng_seed)
node_count = 50
edge_probability = 0.08
mvc_graph = nx.erdos_renyi_graph(
    node_count, edge_probability, seed=rng_seed, directed=False
)

# add node weights
for i in mvc_graph.nodes:
    mvc_graph.add_node(i, weight=_rng.random())

# Optionally, visualize the graph
nx.draw_networkx(mvc_graph, nx.kamada_kawai_layout(mvc_graph), node_size=200)

Model pengoptimuman standard untuk MVC berwajaran boleh diformulasikan seperti berikut. Pertama, penalti mesti ditambah untuk sebarang kes di mana tepi tidak disambungkan kepada bucu dalam subset. Oleh itu, biarkan $n_i = 1$ jika bucu $i$ berada dalam penutup (iaitu, dalam subset) dan $n_i = 0$ sebaliknya. Kedua, matlamat adalah untuk meminimumkan jumlah bilangan bucu dalam subset, yang boleh direpresentasikan oleh fungsi berikut:

$\textbf{Minimize}\qquad y = \sum_{i\in V} \omega_i n_i$

# Construct the cost function.
variables = symbols([f"n[{i}]" for i in range(node_count)])
cost_function = Poly(0, variables)

for i in mvc_graph.nodes():
    weight = mvc_graph.nodes[i].get("weight", 0)
    cost_function += variables[i] * weight

Kini setiap tepi dalam graf mestilah mengandungi sekurang-kurangnya satu titik hujung dari penutup, yang boleh dinyatakan sebagai ketaksamaan:

$n_i + n_j \ge 1 \texttt{ for all } (i,j)\in E$

Sebarang kes di mana tepi tidak disambungkan kepada bucu penutup mesti dikenakan penalti. Ini boleh direpresentasikan dalam fungsi kos dengan menambah penalti berbentuk $P(1-n_i-n_j+n_i n_j)$ di mana $P$ adalah pemalar penalti positif. Oleh itu, alternatif tanpa kekangan kepada ketaksamaan berlandaskan kekangan untuk MVC berwajaran ialah:

$\textbf{Minimize}\qquad y = \sum_{i\in V}\omega_i n_i + P(\sum_{(i,j)\in E}(1 - n_i - n_j + n_i n_j))$

# Add penalty term.
penalty_constant = 2
for i, j in mvc_graph.edges():
    cost_function += penalty_constant * (
        1 - variables[i] - variables[j] + variables[i] * variables[j]
    )

2. Jalankan masalah

# Solve the problem
mvc_job = solver.run(
    problem=srepr(cost_function),
    backend_name=backend_name,  # E.g. "ibm_fez"
)

Semak status beban kerja Fungsi Qiskit anda atau dapatkan semula keputusan seperti berikut:

print(mvc_job.status())

3. Dapatkan keputusan

Dapatkan semula penyelesaian dan analisis keputusan. Kerana masalah ini mempunyai nod berwajaran, penyelesaian bukan sekadar bilangan minimum nod yang dilindungi. Sebaliknya, kos penyelesaian mewakili jumlah wajaran bucu yang termasuk dalam penutup bucu. Ia mewakili jumlah "kos" atau "wajaran" untuk melindungi semua tepi dalam graf menggunakan bucu yang dipilih.

mvc_result = mvc_job.result()
qctrl_cost = mvc_result["solution_bitstring_cost"]

# Print results
print(f"Solution cost: {qctrl_cost}")

Solution cost: 10.248198273708624

Dapatkan sokongan

Untuk sebarang pertanyaan atau isu, hubungi Q-CTRL.

Langkah seterusnya

Cadangan

• Minta akses ke Q-CTRL Optimization Solver.
• Cuba tutorial Selesaikan masalah pengoptimuman binari tertib tinggi dengan Optimization Solver Q-CTRL.
• Semak Sachdeva, N., et al. (2024). Quantum optimization using a 127-qubit gate-model IBM quantum computer can outperform quantum annealers for nontrivial binary optimization problems. arXiv preprint arXiv:2406.01743.
• Semak Loco, D., et al. (2026). Practical protein-pocket hydration-site prediction for drug discovery on a quantum computer. arXiv preprint arXiv:2512.08390.
• Semak kajian kes Mazda.
• Semak kajian kes Network Rail.
• Semak kajian kes Australian Army.
• Semak kajian kes Transport for New South Wales.