Optimization Solver: Qiskit Function oleh Q-CTRL Fire Opal

catatan

Qiskit Functions adalah fitur eksperimental yang hanya tersedia untuk pengguna IBM Quantum® Premium Plan, Flex Plan, dan On-Prem (melalui IBM Quantum Platform API) Plan. Fitur ini dalam status rilis pratinjau dan bisa berubah sewaktu-waktu.

Ikhtisar

Dengan Fire Opal Optimization Solver, kamu bisa memecahkan masalah optimasi skala utilitas di perangkat keras kuantum tanpa perlu keahlian kuantum. Cukup masukkan definisi masalah tingkat tinggi, dan Solver akan menangani sisanya. Seluruh alur kerja bersifat noise-aware dan memanfaatkan Fire Opal's Performance Management di balik layar. Solver secara konsisten menghasilkan solusi yang akurat untuk masalah yang menantang secara klasik, bahkan pada skala perangkat penuh di QPU IBM® terbesar.

Solver bersifat fleksibel dan dapat digunakan untuk memecahkan masalah optimasi kombinatorial yang didefinisikan sebagai fungsi objektif atau graf sembarang. Masalah tidak perlu dipetakan ke topologi perangkat. Baik masalah tidak terkendali maupun terkendali dapat diselesaikan, asalkan kendala dapat dirumuskan sebagai suku penalti. Contoh-contoh yang disertakan dalam panduan ini menunjukkan cara memecahkan masalah optimasi skala utilitas yang tidak terkendali dan terkendali menggunakan berbagai tipe input Solver. Contoh pertama melibatkan masalah Max-Cut yang didefinisikan pada graf 3-Regular dengan 156 simpul, sementara contoh kedua menangani masalah Minimum Vertex Cover 50 simpul yang didefinisikan oleh fungsi biaya.

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

Deskripsi fungsi

Solver sepenuhnya mengoptimalkan dan mengotomatiskan seluruh algoritma, mulai dari supresi kesalahan di tingkat perangkat keras hingga pemetaan masalah yang efisien dan optimasi klasik loop tertutup. Di balik layar, pipeline Solver mengurangi kesalahan di setiap tahap, memungkinkan peningkatan performa yang dibutuhkan untuk penskalaan yang bermakna. Alur kerja yang mendasarinya terinspirasi dari Quantum Approximate Optimization Algorithm (QAOA), yang merupakan algoritma hibrida kuantum-klasik. Untuk ringkasan lengkap alur kerja Optimization Solver, lihat manuskrip yang dipublikasikan.

Untuk memecahkan masalah umum dengan Optimization Solver:

1. Definisikan masalahmu sebagai fungsi objektif, graf, atau rantai spin SparsePauliOp.
2. Hubungkan ke fungsi melalui Qiskit Functions Catalog.
3. Jalankan masalah dengan Solver dan ambil hasilnya.

Input dan output

Input

Nama	Tipe	Deskripsi	Wajib	Default	Contoh
problem	str atau SparsePauliOp	Salah satu representasi yang tercantum di bawah "Format masalah yang diterima"	Ya	N/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 terbatas pada "maxcut" atau "spin_chain"; tidak diperlukan untuk definisi masalah fungsi objektif sembarang	Tidak	None	"maxcut"
backend_name	str	Nama Backend yang akan digunakan	Tidak	Backend paling tidak sibuk yang dapat diakses oleh instance-mu	"ibm_fez"
options	dict	Opsi input, termasuk: (Opsional) session_id: str; perilaku default membuat Session baru	Tidak	None	{"session_id": "cw2q70c79ws0008z6g4g"}

Format masalah yang diterima:

• Representasi ekspresi polinomial dari fungsi objektif. Idealnya dibuat di Python dengan objek SymPy Poly yang sudah ada dan diformat menjadi string menggunakan sympy.srepr.
• Representasi graf dari tipe masalah tertentu. Graf harus dibuat menggunakan library networkx di Python. Kemudian dikonversi ke string menggunakan fungsi networkx [nx.readwrite.json_graph.adjacency_data](http://nx.readwrite.json_graph.adjacency_data.).
• Representasi rantai spin dari masalah tertentu. Rantai spin harus direpresentasikan sebagai objek SparsePauliOp; lihat dokumentasi untuk detail lebih lanjut.

Backend yang didukung: Jalankan kode berikut untuk melihat daftar Backend yang saat ini didukung. Jika perangkatmu tidak terdaftar, hubungi Q-CTRL untuk menambahkan dukungan.

# 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')>]

Opsi:

Nama	Tipe	Deskripsi	Default
session_id	str	ID Session Qiskit Runtime yang sudah ada	"cw4r3je6f0t010870y3g"
job_tags	list[str]	Daftar tag job	[]

Output

Nama	Tipe	Deskripsi	Contoh
result	dict[str, Any]	Solusi dan metadata yang tercantum di bawah "Isi kamus hasil"	{'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': []}

Isi kamus hasil:

Nama	Tipe	Deskripsi
solution_bitstring_cost	float	Biaya minimum terbaik di semua iterasi
final_bitstring_distribution	CountsDict	Kamus hitungan bitstring yang terkait dengan biaya minimum
solution_bitstring	str	Bitstring dengan biaya terbaik dalam distribusi akhir
iteration_count	int	Total jumlah iterasi QAOA yang dilakukan oleh Solver
variables_to_bitstring_index_map	float	Pemetaan dari variabel ke bit yang setara dalam bitstring
best_parameters	list[float]	Parameter beta dan gamma yang dioptimalkan di semua iterasi
warnings	list[str]	Peringatan yang dihasilkan saat mengkompilasi atau menjalankan QAOA (default-nya None)

Tolok ukur

Hasil tolok ukur yang dipublikasikan menunjukkan bahwa Solver berhasil memecahkan masalah dengan lebih dari 120 Qubit, bahkan mengungguli hasil yang sebelumnya dipublikasikan pada anil kuantum dan perangkat ion terjebak. Metrik tolok ukur berikut memberikan indikasi kasar tentang akurasi dan penskalaan tipe masalah berdasarkan beberapa contoh. Metrik aktual bisa berbeda berdasarkan berbagai fitur masalah, seperti jumlah suku dalam fungsi objektif (kepadatan) dan lokalitasnya, jumlah variabel, dan orde polinomial.

"Jumlah Qubit" yang ditunjukkan bukanlah batasan keras tetapi merepresentasikan ambang batas kasar di mana kamu dapat mengharapkan akurasi solusi yang sangat konsisten. Ukuran masalah yang lebih besar telah berhasil dipecahkan, dan pengujian di luar batas ini sangat dianjurkan.

Konektivitas Qubit sembarang didukung di semua tipe masalah.

Tipe masalah	Jumlah Qubit	Contoh	Akurasi	Total waktu (s)	Penggunaan runtime (s)	Jumlah iterasi
Masalah kuadratik dengan koneksi jarang	156	3-regular Max-Cut	100%	1764	293	16
Optimasi biner orde tinggi	156	Model spin-glass Ising	100%	1461	272	16
Masalah kuadratik dengan koneksi padat	50	Max-Cut penuh terkoneksi	100%	1758	268	12
Masalah terkendali dengan suku penalti	50	Weighted Minimum Vertex Cover dengan kepadatan tepi 8%	100%	1074	215	10

Mulai

Pertama, autentikasi menggunakan kunci API IBM Quantum-mu. Kemudian, pilih Qiskit Function sebagai berikut. (Cuplikan ini mengasumsikan kamu sudah menyimpan akunmu ke lingkungan lokalmu.)

from qiskit_ibm_catalog import QiskitFunctionsCatalog

catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")

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

Contoh: Optimasi tidak terkendali

Jalankan masalah maximum cut (Max-Cut). Contoh berikut mendemonstrasikan kemampuan Solver pada masalah Max-Cut graf tidak berbobot 3-regular dengan 156 simpul, tapi kamu juga bisa memecahkan masalah graf berbobot. Selain qiskit-ibm-catalog, kamu juga akan menggunakan paket berikut untuk menjalankan contoh ini: networkx dan numpy. Kamu bisa menginstal paket-paket ini dengan membatalkan komentar sel berikut jika kamu menjalankan contoh ini di notebook menggunakan kernel IPython.

# %pip install networkx numpy

1. Definisikan masalah

Kamu bisa menjalankan masalah Max-Cut dengan mendefinisikan 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 string sebagai input definisi masalah.

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

2. Jalankan masalah

Saat menggunakan metode input berbasis graf, tentukan tipe 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"
)

Periksa status workload Qiskit Function-mu atau ambil hasil sebagai berikut:

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

QUEUED

3. Ambil hasilnya

Ambil nilai potongan optimal dari kamus hasil.

catatan

Pemetaan variabel ke bitstring mungkin telah berubah. Kamus output berisi sub-kamus variables_to_bitstring_index_map, yang membantu memverifikasi urutannya.

# 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

Kamu bisa memverifikasi akurasi hasil dengan memecahkan masalah secara klasik menggunakan solver open-source seperti PuLP jika graf tidak terhubung padat. Masalah dengan kepadatan tinggi mungkin memerlukan solver klasik tingkat lanjut untuk memvalidasi solusinya.

Contoh: Optimasi terkendali

Contoh Max-Cut sebelumnya adalah masalah optimasi biner kuadratik tidak terkendali yang umum. Optimization Solver Q-CTRL dapat digunakan untuk berbagai tipe masalah, termasuk optimasi terkendali. Kamu bisa memecahkan tipe masalah sembarang dengan memasukkan definisi masalah yang direpresentasikan sebagai polinomial di mana kendala dimodelkan sebagai suku penalti.

Contoh berikut mendemonstrasikan cara membangun fungsi biaya untuk masalah optimasi terkendali, minimum vertex cover (MVC). Selain paket qiskit-ibm-catalog dan qiskit, kamu juga akan menggunakan paket berikut untuk menjalankan contoh ini: numpy, networkx, dan sympy. Kamu bisa menginstal paket-paket ini dengan membatalkan komentar sel berikut jika kamu menjalankan contoh ini di notebook menggunakan kernel IPython.

# %pip install numpy networkx sympy

1. Definisikan masalah

Definisikan masalah MVC acak dengan membuat graf dengan simpul berbobot acak.

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 optimasi standar untuk MVC berbobot dapat dirumuskan sebagai berikut. Pertama, penalti harus ditambahkan untuk setiap kasus di mana sebuah tepi tidak terhubung ke simpul dalam subset. Oleh karena itu, misalkan $n_i = 1$ jika simpul $i$ ada dalam cover (yaitu, dalam subset) dan $n_i = 0$ jika tidak. Kedua, tujuannya adalah meminimalkan jumlah total simpul dalam subset, yang dapat 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

Sekarang setiap tepi dalam graf harus menyertakan setidaknya satu titik ujung dari cover, yang dapat diekspresikan sebagai ketidaksamaan:

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

Setiap kasus di mana sebuah tepi tidak terhubung ke simpul cover harus dikenai penalti. Ini dapat direpresentasikan dalam fungsi biaya dengan menambahkan penalti berbentuk $P(1-n_i-n_j+n_i n_j)$ di mana $P$ adalah konstanta penalti positif. Dengan demikian, alternatif tidak terkendali untuk ketidaksamaan terkendali pada MVC berbobot adalah:

$\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"
)

Periksa status workload Qiskit Function-mu atau ambil hasil sebagai berikut:

print(mvc_job.status())

3. Dapatkan hasilnya

Ambil solusi dan analisis hasilnya. Karena masalah ini memiliki simpul berbobot, solusinya bukan sekadar jumlah minimum simpul yang dicakup. Sebaliknya, biaya solusi merepresentasikan jumlah bobot simpul yang termasuk dalam vertex cover. Ini merepresentasikan total "biaya" atau "bobot" untuk mencakup semua tepi dalam graf menggunakan simpul 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 dukungan

Untuk pertanyaan atau masalah apa pun, hubungi Q-CTRL.

Langkah selanjutnya

Rekomendasi

• Minta akses ke Q-CTRL Optimization Solver.
• Coba tutorial Solve higher-order binary optimization problems with Q-CTRL's Optimization Solver.
• Tinjau 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.
• Tinjau Loco, D., et al. (2026). Practical protein-pocket hydration-site prediction for drug discovery on a quantum computer. arXiv preprint arXiv:2512.08390.
• Tinjau studi kasus Mazda.
• Tinjau studi kasus Network Rail.
• Tinjau studi kasus Australian Army.
• Tinjau studi kasus Transport for New South Wales.