Iskay Quantum Optimizer - Fungsi Qiskit oleh Kipu Quantum

See the API reference

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 dapat berubah sewaktu-waktu.

Gambaran Umum

Dengan Iskay Quantum Optimizer dari Kipu Quantum, kamu bisa menangani masalah optimasi yang kompleks menggunakan komputer kuantum IBM®. Solver ini memanfaatkan algoritma bf-DCQO mutakhir dari Kipu yang hanya membutuhkan fungsi objektif sebagai input untuk secara otomatis menghasilkan solusi masalah. Optimizer ini bisa menangani masalah optimasi hingga 156 qubit, sehingga memungkinkan penggunaan semua qubit pada perangkat kuantum IBM. Optimizer menggunakan pemetaan 1-ke-1 antara variabel klasik dan qubit, yang memungkinkan kamu menangani masalah optimasi dengan hingga 156 variabel biner.

Optimizer ini memungkinkan penyelesaian masalah optimasi biner tanpa kendala. Selain formulasi QUBO (Quadratic Unconstrained Binary Optimization) yang umum digunakan, ia juga mendukung masalah optimasi orde tinggi (HUBO). Solver ini menggunakan algoritma kuantum non-variasional, yang menjalankan sebagian besar komputasi pada perangkat kuantum.

Berikut ini informasi lebih lanjut tentang algoritma yang digunakan dan panduan singkat cara menggunakan fungsi ini, beserta hasil benchmark pada berbagai instance masalah dengan ukuran dan kompleksitas yang berbeda-beda.

Deskripsi

Optimizer ini adalah implementasi siap pakai dari algoritma optimasi kuantum mutakhir. Ia menyelesaikan masalah optimasi dengan menjalankan sirkuit kuantum yang sangat dikompresi pada perangkat keras kuantum. Kompresi ini dicapai dengan memasukkan suku-suku counterdiabatic ke dalam evolusi waktu yang mendasari sistem kuantum. Algoritma ini menjalankan beberapa iterasi eksekusi perangkat keras untuk mendapatkan solusi akhir dan menggabungkannya dengan pasca-pemrosesan. Langkah-langkah ini terintegrasi secara mulus ke dalam alur kerja Optimizer dan dieksekusi secara otomatis.

Bagaimana cara kerja Quantum Optimizer?

Bagian ini menguraikan dasar-dasar algoritma bf-DCQO yang diimplementasikan. Pengenalan algoritma ini juga bisa ditemukan di saluran YouTube Qiskit.

Algoritma ini didasarkan pada evolusi waktu sistem kuantum yang berubah seiring waktu, di mana solusi masalah dikodekan dalam ground state sistem kuantum di akhir evolusi. Menurut teorema adiabatik, evolusi ini harus berlangsung lambat untuk memastikan sistem tetap berada di ground state-nya. Mendigitalisasi evolusi ini adalah dasar dari komputasi adiabatik kuantum terdigitalisasi (DQA) dan algoritma QAOA yang terkenal. Namun, evolusi lambat yang diperlukan tidak layak untuk ukuran masalah yang semakin besar karena menghasilkan kedalaman sirkuit yang semakin bertambah. Dengan menggunakan protokol counterdiabatic, kamu bisa menekan eksitasi yang tidak diinginkan yang terjadi selama waktu evolusi singkat sambil tetap berada di ground state. Di sini, mendigitalisasi waktu evolusi yang lebih singkat ini menghasilkan sirkuit kuantum dengan kedalaman lebih pendek dan lebih sedikit gate yang berpilin.

Sirkuit algoritma bf-DCQO biasanya menggunakan hingga sepuluh kali lebih sedikit gate yang berpilin dibandingkan DQA, dan tiga hingga empat kali lebih sedikit gate yang berpilin dibandingkan implementasi QAOA standar. Karena jumlah gate yang lebih sedikit, lebih sedikit kesalahan yang terjadi selama eksekusi sirkuit pada perangkat keras. Oleh karena itu, optimizer ini tidak memerlukan teknik seperti penekanan kesalahan atau mitigasi kesalahan. Mengimplementasikannya di versi mendatang dapat meningkatkan kualitas solusi lebih jauh.

Meskipun algoritma bf-DCQO menggunakan iterasi, ia bersifat non-variasional. Setelah setiap iterasi algoritma, distribusi state diukur. Distribusi yang diperoleh digunakan untuk menghitung apa yang disebut bias-field. Bias-field memungkinkan memulai iterasi berikutnya dari state energi mendekati solusi yang ditemukan sebelumnya. Dengan cara ini, algoritma bergerak dengan setiap iterasi menuju solusi berenergi lebih rendah. Biasanya, sekitar sepuluh iterasi sudah cukup untuk mencapai konvergensi ke solusi, secara keseluruhan memerlukan jumlah iterasi yang jauh lebih sedikit dibandingkan algoritma variasional, yang berada dalam urutan sekitar 100 iterasi.

Optimizer ini menggabungkan algoritma bf-DCQO dengan pasca-pemrosesan klasik. Setelah mengukur distribusi state, dilakukan pencarian lokal. Selama pencarian lokal, bit-bit dari solusi yang diukur dibalik secara acak. Setelah pembalikan, energi dari bitstring baru dievaluasi. Jika energinya lebih rendah, bitstring tersebut disimpan sebagai solusi baru. Pencarian lokal hanya berskala linier dengan jumlah qubit; karenanya, ini murah secara komputasi. Karena pasca-pemrosesan mengoreksi bitflip lokal, ia mengkompensasi kesalahan bit-flip yang sering merupakan hasil dari ketidaksempurnaan perangkat keras dan kesalahan pembacaan.

Alur kerja

Berikut adalah skema alur kerja Quantum Optimizer.

Dengan menggunakan Quantum Optimizer, penyelesaian masalah optimasi pada perangkat keras kuantum dapat disederhanakan menjadi:

• Merumuskan fungsi objektif dari masalah
• Mengakses Optimizer melalui Qiskit Functions
• Menjalankan Optimizer dan mengumpulkan hasilnya

Benchmark

Metrik benchmark di bawah ini menunjukkan bahwa Optimizer secara efektif menangani masalah yang melibatkan hingga 156 qubit dan memberikan gambaran umum tentang akurasi dan skalabilitas optimizer di berbagai jenis masalah. Perhatikan bahwa metrik performa aktual mungkin bervariasi tergantung pada karakteristik masalah tertentu, seperti jumlah variabel, kepadatan dan lokalitas suku-suku dalam fungsi objektif, dan orde polinomial.

Tabel berikut mencantumkan rasio aproksimasi (AR), metrik yang didefinisikan sebagai berikut:

$$AR = \frac{C^{*} - C_\textrm{max}}{C_{\textrm{min}} - C_{\textrm{max}}},$$

di mana $C$ adalah fungsi objektif, $C_{\textrm{min}}$, $C_{\textrm{max}}$ adalah nilai minimum dan maksimumnya, dan $C^{*}$ adalah biaya solusi terbaik yang ditemukan, masing-masing. Oleh karena itu, AR=100% berarti ground state dari masalah telah diperoleh.

Contoh	Jumlah qubit	Rasio Aproksimasi	Total waktu (s)	Penggunaan runtime (s)	Total jumlah shot	Jumlah iterasi
Unweighted MaxCut	28	100%	180	30	30k	5
Unweighted MaxCut	30	100%	180	30	30k	5
Unweighted MaxCut	32	100%	180	30	30k	5
Unweighted MaxCut	80	100%	480	60	90k	9
Unweighted MaxCut	100	100%	330	60	60k	6
Unweighted MaxCut	120	100%	370	60	60k	6
HUBO 1	156	100%	600	70	100k	10
HUBO 2	156	100%	600	70	100k	10

• Instance MaxCut dengan 28, 30, dan 32 qubit dijalankan pada ibm_sherbrooke. Instance dengan 80, 100, dan 120 dijalankan pada prosesor Heron r2.
• Instance HUBO juga dijalankan pada prosesor Heron r2.

Semua instance benchmark tersedia di GitHub (lihat Kipu benchmark instances). Contoh untuk menjalankan instance ini bisa ditemukan di Contoh 3: Instance benchmark.

Mulai

Dalam dokumentasi ini, kita akan melalui langkah-langkah menggunakan Iskay Quantum Optimizer. Dalam prosesnya kita akan dengan cepat menunjukkan cara memuat fungsi dari catalog dan cara mengonversi masalahmu ke input yang valid, sekaligus menunjukkan cara bereksperimen dengan berbagai parameter opsional yang berbeda.

Untuk contoh yang lebih detail, silakan lihat tutorial Selesaikan masalah Market Split dengan Iskay Quantum Optimizer dari Kipu Quantum, di mana kita bekerja melalui seluruh proses menggunakan Iskay Solver untuk menangani masalah Market Split, yang mewakili tantangan alokasi sumber daya dunia nyata di mana pasar harus dipartisi ke dalam wilayah penjualan yang seimbang untuk memenuhi target permintaan yang tepat.

Autentikasi menggunakan API key-mu, yang bisa ditemukan di dashboard IBM Quantum Platform, dan pilih Qiskit Function sebagai berikut:

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

# ruff: noqa: F821

catatan

Kode berikut mengasumsikan bahwa kamu telah menyimpan kredensialmu. Jika belum, ikuti instruksi di simpan akun IBM Cloud-mu untuk mengautentikasi dengan API key-mu.

from qiskit_ibm_catalog import QiskitFunctionsCatalog

catalog = QiskitFunctionsCatalog(
    channel="ibm_quantum_platform",
    instance="INSTANCE_CRN",
    # For `token`, use the 44-character API_KEY you created
    # and saved from the IBM Quantum Platform Home dashboard
    token="YOUR_API_KEY",
)

# Access Function
optimizer = catalog.load("kipu-quantum/iskay-quantum-optimizer")

Contoh konfigurasi kustom

Berikut cara kamu mengonfigurasi Iskay dengan pengaturan berbeda:

custom_options = {
    "shots": 15_000,  # Higher shot count for better statistics
    "num_iterations": 12,  # More iterations for solution refinement
    "preprocessing_level": 1,  # Light preprocessing for problem simplification
    "postprocessing_level": 2,  # Maximum postprocessing for solution quality
    "transpilation_level": 3,  # Use higher transpilation level to optimize circuit
    "seed_transpiler": 42,  # Fixed seed for reproducible results
    "job_tags": ["custom_config"],  # Custom tracking tags
}

Optimasi seed: Perhatikan bahwa seed_transpiler diatur ke None secara default. Ini mengaktifkan proses optimasi otomatis transpiler. Ketika None, sistem akan memulai percobaan dengan beberapa seed dan memilih yang menghasilkan kedalaman sirkuit terbaik, memanfaatkan sepenuhnya parameter max_trials untuk setiap level transpilasi.

Performa level transpilasi: Meningkatkan jumlah max_trials dengan nilai transpilation_level yang lebih tinggi pasti akan meningkatkan waktu transpilasi, tetapi mungkin tidak selalu mengubah sirkuit akhir — ini sangat tergantung pada struktur dan kompleksitas sirkuit tertentu. Untuk beberapa sirkuit/masalah, bagaimanapun, perbedaan antara 10 percobaan (level 1) dan 50 percobaan (level 5) bisa sangat dramatis, jadi mengeksplorasi parameter ini mungkin menjadi kunci untuk berhasil menemukan solusi.

Contoh 1: Fungsi biaya sederhana

Perhatikan fungsi biaya dalam formulasi spin:

$$C(x_0, x_1, x_2, x_3, x_4) = 1 + 1.5x_0 + 2x_1 + 1.3x_2 + 2.5x_0x_3 + 3.5x_1x_4 + 4x_0x_1x_2$$

di mana $(x_0, ..., x_4) \in \{-1, 1\}^5$.

Solusi untuk fungsi biaya sederhana ini adalah

$$(x_0, x_1, x_2, x_3, x_4) = (-1, -1, -1, 1, 1)$$

dengan nilai minimum $C^{*} = -6$

1. Buat fungsi objektif

Kita mulai dengan membuat dictionary berisi koefisien fungsi objektif sebagai berikut:

objective_func = {
    "()": 1,
    "(0,)": 1.5,
    "(1,)": 2,
    "(2,)": 1.3,
    "(0, 3)": 2.5,
    "(1, 4)": 3.5,
    "(0, 1, 2)": 4,
}

2. Jalankan Optimizer

Kita selesaikan masalahnya dengan menjalankan optimizer. Karena $(x_0, ..., x_4) \in \{-1, 1\}^5$, kita harus mengatur problem_type=spin.

# Setup options to run the optimizer
options = {"shots": 5000, "num_iterations": 5, "use_session": True}

arguments = {
    "problem": objective_func,
    "problem_type": "spin",
    "backend_name": backend_name,  # such as "ibm_fez"
    "options": options,
}

job = optimizer.run(**arguments)

3. Ambil hasilnya

Solusi dari masalah optimasi diberikan langsung dari optimizer.

print(job.result())

Ini akan menampilkan dictionary dengan bentuk:

{'solution': {'0': -1, '1': -1, '2': -1, '3': 1, '4': 1},
 'solution_info': {'bitstring': '11100',
  'cost': -13.8,
  'seed_transpiler': 42,
  'mapping': {0: 0, 1: 1, 2: 2, 3: 3, 4: 4}},
 'prob_type': 'spin'}

Perhatikan bahwa dictionary solution menampilkan vektor hasil $(x_0, x_1, x_2, x_3, x_4) = (-1, -1, -1, 1, 1)$.

Contoh 2: MaxCut

Banyak masalah graf seperti MaxCut atau Maximum Independent Set adalah masalah NP-hard dan merupakan kandidat ideal untuk menguji algoritma dan perangkat keras kuantum. Contoh ini menunjukkan cara menyelesaikan masalah MaxCut pada graf 3-regular menggunakan Quantum Optimizer.

Untuk menjalankan contoh ini, kamu harus menginstal paket networkx selain qiskit-ibm-catalog. Untuk menginstalnya, jalankan perintah berikut:

# %pip install networkx numpy

1. Buat fungsi objektif

Mulai dengan membuat graf 3-regular acak. Untuk graf ini, kita definisikan fungsi objektif dari masalah MaxCut.

import networkx as nx

# Create a random 3-regular graph
G = nx.random_regular_graph(3, 10, seed=42)

# Create the objective function for MaxCut in Ising formulation
def graph_to_ising_maxcut(G):
    """
    Convert a NetworkX graph to an Ising Hamiltonian for the max-cut problem.
    Args:
        G (networkx.Graph): The input graph.
    Returns:
        dict: The objective function of the Ising model
    """
    # Initialize the linear and quadratic coefficients
    objective_func = {}
    # Populate the coefficients
    for i, j in G.edges:
        objective_func[f"({i}, {j})"] = 0.5
    return objective_func

objective_func = graph_to_ising_maxcut(G)

2. Jalankan Optimizer

Selesaikan masalahnya dengan menjalankan optimizer.

options = {"shots": 5000, "num_iterations": 5, "use_session": True}

arguments = {
    "problem": objective_func,
    "problem_type": "spin",
    "backend_name": backend_name,  # such as "ibm_fez"
    "options": options,
}

job = optimizer.run(**arguments)

3. Ambil hasilnya

Ambil hasilnya dan petakan bitstring solusi kembali ke node graf aslinya.

print(job.result())

Solusi untuk masalah Maxcut langsung terdapat dalam sub-dictionary solution dari objek hasil

maxcut_solution = job.result()["solution"]

Contoh 3: Instance benchmark

Instance benchmark tersedia di GitHub: Instance benchmark Kipu.

Instance tersebut bisa dimuat menggunakan library pygithub. Untuk menginstalnya, jalankan perintah berikut:

# %pip install pygithub

Path untuk instance benchmark adalah:

Maxcut:

• 'maxcut/maxcut_regular_3_100_nodes_weighted.json'
• 'maxcut/maxcut_regular_3_140_nodes_weighted.json'
• 'maxcut/maxcut_regular_3_150_nodes_weighted.json'
• 'maxcut/maxcut_regular_4_130_nodes_weighted.json'

HUBO:

• 'HUBO/hubo1_marrakesh.json'
• 'HUBO/hubo2_marrakesh.json'

Untuk mereproduksi performa benchmark pada instance HUBO, pilih backend ibm_marrakesh dan atur direct_qubit_mapping ke True pada sub-dictionary options. Contoh berikut menjalankan instance Maxcut dengan 150 node.

from github import Github
import urllib
import json
import ast

repo = "Kipu-Quantum-GmbH/benchmark-instances"
path = "maxcut/maxcut_regular_3_150_nodes_weighted.json"
gh = Github()
repo = gh.get_repo(repo)
branch = "main"
file = repo.get_contents(urllib.parse.quote(path), ref=branch)

# load json file with benchmark problem
problem_json = json.loads(file.decoded_content)

# convert objective function to compatible format
objective_func = {
    key: ast.literal_eval(value) for key, value in problem_json.items()
}

# Setup configuration to run the optimizer
options = {
    "shots": 5_000,
    "num_iterations": 5,
    "use_session": True,
    "direct_qubit_mapping": False,
}

arguments = {
    "problem": objective_func,
    "problem_type": "spin",
    "backend_name": "<BACKEND-NAME>",
    "options": options,
}

job = optimizer.run(**arguments)

result = job.result()

Kasus penggunaan

Kasus penggunaan umum untuk solver Optimasi ini adalah masalah optimasi kombinatorial. Kamu bisa menyelesaikan masalah dari berbagai industri seperti keuangan, farmasi, atau logistik. Beberapa contoh berikut ini.

• Optimasi portofolio (QUBO): publikasi ilmiah dan white paper
• Pelipatan protein (HUBO): publikasi ilmiah
• Penjadwalan logistik (QUBO): publikasi ilmiah
• Optimasi jaringan: webinar
• Pemisahan pasar (QUBO): tutorial

Jika kamu tertarik menangani kasus penggunaan tertentu dan mengembangkan pemetaan khusus, kami siap membantu. Hubungi kami.

Dapatkan dukungan

Untuk dukungan, hubungi support@kipu-quantum.com.

Langkah selanjutnya

• Minta akses ke Quantum Optimizer dari Kipu Quantum.
• Kunjungi referensi API untuk Qiskit Function ini.
• Coba tutorial Selesaikan masalah Market Split dengan Iskay Quantum Optimizer dari Kipu Quantum.
• Tinjau Romero, S. V., et al. (2025). Bias-Field Digitized Counterdiabatic Quantum Algorithm for Higher-Order Binary Optimization. arXiv preprint arXiv:2409.04477.
• Tinjau Cadavid, A. G., et al. (2024). Bias-field digitized counterdiabatic quantum optimization. arXiv preprint arXiv:2405.13898.
• Tinjau Chandarana, P., et al. (2025). Runtime Quantum Advantage with Digital Quantum Optimization. arXiv preprint arXiv:2505.08663.

Informasi tambahan

Iskay, seperti nama perusahaan kami Kipu Quantum, adalah kata dari Peru. Meskipun kami adalah startup dari Jerman, kata-kata ini berasal dari tanah asal salah satu co-founder kami, di mana Quipu adalah salah satu mesin kalkulasi pertama yang dikembangkan oleh manusia 2000 tahun SM.