Optimization Solver: Qiskit Function oleh Q-CTRL Fire Opal

Lihat referensi API

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.

Versi paket

Kode di halaman ini dikembangkan menggunakan persyaratan berikut. Kami merekomendasikan menggunakan versi ini atau yang lebih baru.

qiskit-ibm-runtime~=0.46.1
sympy~=1.14.0

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.

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.

Apakah fungsi ini mendukung semua Backend IBM?

Jika kamu ingin menggunakan Backend yang belum didukung oleh fungsi ini, hubungi Q-CTRL untuk menambahkan dukungan.

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

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

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: 210.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())

QUEUED

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.

Changelog

• 2026-02-11: Kami sekarang mendukung ibm_miami

Langkah selanjutnya

Rekomendasi

• Minta akses ke Q-CTRL Optimization Solver.
• Kunjungi referensi API untuk Qiskit Function ini.
• 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.