Iskay Quantum Optimizer - Fungsi Qiskit oleh Kipu Quantum

Nota

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

Gambaran keseluruhan

Dengan Iskay Quantum Optimizer oleh Kipu Quantum, anda boleh menangani masalah pengoptimuman yang rumit menggunakan komputer kuantum IBM®. Penyelesai ini memanfaatkan algoritma bf-DCQO mutakhir Kipu yang hanya memerlukan fungsi objektif sebagai input untuk menghasilkan penyelesaian masalah secara automatik. Ia boleh mengendalikan masalah pengoptimuman yang melibatkan sehingga 156 qubit, membolehkan penggunaan semua qubit pada peranti kuantum IBM. Pengoptimum menggunakan pemetaan 1-ke-1 antara pemboleh ubah klasik dan qubit, yang membolehkan anda menangani masalah pengoptimuman dengan sehingga 156 pemboleh ubah binari.

Pengoptimum ini membolehkan penyelesaian masalah pengoptimuman binari tanpa kekangan. Selain formulasi QUBO (Quadratic Unconstrained Binary Optimization) yang lazim digunakan, ia juga menyokong masalah pengoptimuman peringkat tinggi (HUBO). Penyelesai ini menggunakan algoritma kuantum bukan variasi, yang menjalankan sebahagian besar pengiraan pada peranti kuantum.

Berikut memberikan lebih butiran tentang algoritma yang digunakan dan panduan ringkas tentang cara menggunakan fungsi ini, serta keputusan penanda aras pada pelbagai contoh masalah dengan saiz dan kerumitan yang berbeza.

Penerangan

Pengoptimum ini ialah pelaksanaan sedia guna bagi algoritma pengoptimuman kuantum mutakhir. Ia menyelesaikan masalah pengoptimuman dengan menjalankan litar kuantum yang dimampatkan dengan ketara pada perkakasan kuantum. Pemampatan ini dicapai dengan memperkenalkan sebutan counterdiabatic ke dalam evolusi masa asas sistem kuantum. Algoritma menjalankan beberapa lelaran proses perkakasan untuk memperoleh penyelesaian akhir dan menggabungkannya dengan pasca-pemprosesan. Langkah-langkah ini disepadukan dengan lancar ke dalam alur kerja Pengoptimum dan dilaksanakan secara automatik.

Bagaimana Pengoptimum Kuantum berfungsi?

Bahagian ini menggariskan asas algoritma bf-DCQO yang dilaksanakan. Pengenalan kepada algoritma ini juga boleh didapati di saluran YouTube Qiskit.

Algoritma ini berasaskan evolusi masa sistem kuantum yang berubah dari semasa ke semasa, di mana penyelesaian masalah dikodkan dalam keadaan asas sistem kuantum pada penghujung evolusi. Menurut teorem adiabatik, evolusi ini mesti berlaku perlahan untuk memastikan sistem kekal dalam keadaan asasnya. Mendigitkan evolusi ini adalah asas kepada pengiraan adiabatik kuantum terdigit (DQA) dan algoritma QAOA yang terkenal. Walau bagaimanapun, evolusi perlahan yang diperlukan tidak praktikal untuk saiz masalah yang semakin besar kerana ia menghasilkan kedalaman litar yang semakin meningkat. Dengan menggunakan protokol counterdiabatic, anda boleh menindas pengujaan yang tidak diingini semasa masa evolusi yang singkat sambil kekal dalam keadaan asas. Di sini, mendigitkan masa evolusi yang lebih singkat ini menghasilkan litar kuantum dengan kedalaman yang lebih pendek dan bilangan get yang mengaitkan yang lebih sedikit.

Litar algoritma bf-DCQO biasanya menggunakan sehingga sepuluh kali lebih sedikit get pengkaitan berbanding DQA, dan tiga hingga empat kali lebih sedikit get pengkaitan berbanding pelaksanaan QAOA standard. Disebabkan bilangan get yang lebih kecil, lebih sedikit ralat berlaku semasa pelaksanaan litar pada perkakasan. Oleh itu, pengoptimum ini tidak memerlukan penggunaan teknik seperti penindasan ralat atau pengurangan ralat. Melaksanakannya dalam versi masa depan boleh meningkatkan kualiti penyelesaian dengan lebih lanjut.

Walaupun algoritma bf-DCQO menggunakan lelaran, ia bukan variasi. Selepas setiap lelaran algoritma, taburan keadaan diukur. Taburan yang diperoleh digunakan untuk mengira medan berat sebelah (bias-field). Medan berat sebelah membolehkan permulaan lelaran seterusnya dari keadaan tenaga yang hampir dengan penyelesaian yang ditemui sebelumnya. Dengan cara ini, algoritma bergerak dengan setiap lelaran ke arah penyelesaian dengan tenaga yang lebih rendah. Biasanya, kira-kira sepuluh lelaran sudah mencukupi untuk menumpu kepada penyelesaian, dengan jumlah bilangan lelaran yang jauh lebih rendah berbanding algoritma variasi, iaitu dalam susunan kira-kira 100 lelaran.

Pengoptimum menggabungkan algoritma bf-DCQO dengan pasca-pemprosesan klasik. Selepas mengukur taburan keadaan, carian tempatan dilakukan. Semasa carian tempatan, bit penyelesaian yang diukur dibalikkan secara rawak. Selepas pembalikan, tenaga bitstring baru dinilai. Jika tenaganya lebih rendah, bitstring itu dikekalkan sebagai penyelesaian baru. Carian tempatan hanya berskala secara linear dengan bilangan qubit; oleh itu, ia murah dari segi pengiraan. Oleh kerana pasca-pemprosesan membetulkan pembalikan bit setempat, ia mengimbangi ralat pembalikan bit yang sering menjadi hasil ketidaksempurnaan perkakasan dan ralat pembacaan.

Alur kerja

Berikut ialah skema alur kerja Pengoptimum Kuantum.

Alur kerja

Dengan menggunakan Pengoptimum Kuantum, menyelesaikan masalah pengoptimuman pada perkakasan kuantum boleh dikurangkan kepada:

Merumuskan fungsi objektif masalah
Mengakses Pengoptimum melalui Fungsi Qiskit
Menjalankan Pengoptimum dan mengumpul keputusan

Penanda aras

Metrik penanda aras di bawah menunjukkan bahawa Pengoptimum menangani masalah yang melibatkan sehingga 156 qubit dengan berkesan dan memberikan gambaran keseluruhan ketepatan dan kebolehskalaan pengoptimum merentasi pelbagai jenis masalah. Perhatikan bahawa metrik prestasi sebenar mungkin berbeza bergantung pada ciri masalah tertentu, seperti bilangan pemboleh ubah, ketumpatan dan lokaliti sebutan dalam fungsi objektif, dan peringkat polinomial.

Jadual berikut merangkumi nisbah penghampiran (AR), iaitu metrik yang ditakrifkan seperti berikut:

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

di mana $C$ ialah fungsi objektif, $C_{\textrm{min}}$ , $C_{\textrm{max}}$ ialah nilai minimum dan maksimumnya, dan $C^{*}$ ialah kos penyelesaian terbaik yang ditemui. Oleh itu, AR=100% bermakna keadaan asas masalah telah diperoleh.

Contoh	Bilangan qubit	Nisbah Penghampiran	Jumlah masa (s)	Penggunaan Runtime (s)	Jumlah bilangan shot	Bilangan lelaran
MaxCut Tidak Berwajaran	28	100%	180	30	30k	5
MaxCut Tidak Berwajaran	30	100%	180	30	30k	5
MaxCut Tidak Berwajaran	32	100%	180	30	30k	5
MaxCut Tidak Berwajaran	80	100%	480	60	90k	9
MaxCut Tidak Berwajaran	100	100%	330	60	60k	6
MaxCut Tidak Berwajaran	120	100%	370	60	60k	6
HUBO 1	156	100%	600	70	100k	10
HUBO 2	156	100%	600	70	100k	10

Contoh MaxCut dengan 28, 30, dan 32 qubit telah dijalankan pada ibm_sherbrooke. Contoh dengan 80, 100, dan 120 dijalankan pada pemproses Heron r2.
Contoh HUBO juga dijalankan pada pemproses Heron r2.

Semua contoh penanda aras boleh diakses di GitHub (lihat contoh penanda aras Kipu). Contoh untuk menjalankan contoh ini boleh didapati dalam Contoh 3: Contoh penanda aras.

Input dan output

Input

Lihat jadual berikut untuk semua parameter input yang diterima oleh Pengoptimum Kuantum. Bahagian Pilihan seterusnya memberikan lebih butiran tentang options yang tersedia.

Nama	Jenis	Penerangan	Diperlukan	Lalai	Contoh
problem	`Dict[str, float]`	Pekali masalah pengoptimuman yang dirumuskan sebagai QUBO/HUBO atau format spin. Untuk maklumat lanjut tentang spesifikasi masalah, lihat Format masalah yang diterima	Ya	T/A	`{"()": -21.0, "(0, 4)": 0.5,"(0, 2)": 0.5,"(0, 1)": 0.5,"(1, 3)": 0.5}`
problem_type	`str`	Nyatakan sama ada pekali masalah berada dalam format binari (QUBO/HUBO) atau format spin. Dua kemungkinan ialah `"spin"` atau `"binary"`	Ya	T/A	`"spin"`
backend_name	`str`	Nama Backend untuk membuat pertanyaan	Ya	T/A	`"ibm_fez"`
options	`Dict[str, Any]`	Pilihan untuk mengendalikan penghantaran perkakasan, seperti bilangan shot. Untuk butiran lanjut tentang konfigurasi pilihan, lihat bahagian Pilihan	Tidak	Untuk melihat nilai lalai konfigurasi pilihan, lihat bahagian Pilihan	`{"shots": 5000, "num_iterations": 3, "use_session": True, "seed_transpiler": 42}`

Format masalah yang diterima

Argumen problem dan problem_type mengekodkan masalah pengoptimuman dalam bentuk

\begin{align} \min_{(x_1, x_2, \ldots, x_n) \in D} C(x_1, x_2, \ldots, x_n) \nonumber \end{align}

di mana

C(x_1, ... , x_n) = a + \sum_{i} b_i x_i + \sum_{i, j} c_{i, j} x_i x_j + ... + \sum_{k_1, ..., k_m} g_{k_1, ..., k_m} x_{k_1} ... x_{k_m}

Dengan memilih problem_type = "binary", anda menyatakan bahawa fungsi kos berada dalam format binary, yang bermakna $D = \{0, 1\}^{n}$ , iaitu fungsi kos ditulis dalam formulasi QUBO/HUBO.
Sebaliknya, dengan memilih problem_type = "spin", fungsi kos ditulis dalam formulasi Ising, di mana $D = \{-1, 1\}^{n}$ .

Pekali masalah hendaklah dikodkan dalam kamus seperti berikut:

\begin{align} \nonumber &\texttt{\{} \\ \nonumber &\texttt{"()"}&: \quad &a, \\ \nonumber &\texttt{"(i,)"}&: \quad &b_i, \\ \nonumber &\texttt{"(i, j)"}&: \quad &c_{i, j}, \\ \nonumber &\quad \vdots \\ \nonumber &\texttt{"(} k_1, ..., k_m \texttt{)"} &: \quad &g_{k_1, ..., k_m}, \\ \nonumber &\texttt{\}} \end{align}

Sila ambil perhatian bahawa kunci kamus mestilah rentetan yang mengandungi tupel integer tidak berulang yang sah.

Pilihan

Iskay menyediakan keupayaan pelarasan halus melalui parameter pilihan. Walaupun nilai lalai berfungsi dengan baik untuk kebanyakan masalah, anda boleh menyesuaikan tingkah laku untuk keperluan tertentu:

Parameter	Jenis	Lalai	Penerangan
shots	`int`	10000	Pengukuran kuantum setiap lelaran (lebih tinggi = lebih tepat)
num_iterations	`int`	10	Lelaran algoritma (lebih banyak lelaran boleh meningkatkan kualiti penyelesaian)
use_session	`bool`	True	Gunakan Session IBM untuk masa giliran yang lebih singkat
seed_transpiler	`int`	None	Tetapkan untuk kompilasi Circuit kuantum yang boleh dihasilkan semula
direct_qubit_mapping	`bool`	False	Petakan qubit maya secara langsung ke qubit fizikal
job_tags	`List[str]`	None	Tag tersuai untuk penjejakan kerja
preprocessing_level	`int`	0	Intensiti pra-pemprosesan masalah (0-3) - lihat butiran di bawah
postprocessing_level	`int`	2	Tahap penghalusan penyelesaian (0-2) - lihat butiran di bawah
transpilation_level	`int`	0	Percubaan pengoptimuman Transpiler (0-5) - lihat butiran di bawah
transpile_only	`bool`	False	Analisis pengoptimuman Circuit tanpa menjalankan pelaksanaan penuh

Tahap Pra-pemprosesan (0-3): Penting terutamanya untuk masalah yang lebih besar yang pada masa ini tidak sesuai dengan masa koherensi perkakasan. Tahap pra-pemprosesan yang lebih tinggi mencapai kedalaman litar yang lebih cetek melalui penghampiran dalam transpilasi masalah:

Tahap 0: Tepat, litar lebih panjang
Tahap 1: Keseimbangan baik antara ketepatan dan penghampiran, memotong hanya get dengan sudut dalam peratusan ke-10 terendah
Tahap 2: Penghampiran sedikit lebih tinggi, memotong get dengan sudut dalam peratusan ke-20 terendah dan menggunakan approximation_degree=0.95 dalam transpilasi
Tahap 3: Tahap penghampiran maksimum, memotong get dalam peratusan ke-30 terendah dan menggunakan approximation_degree=0.90 dalam transpilasi

Tahap Transpilasi (0-5): Kawal percubaan pengoptimuman Transpiler lanjutan untuk kompilasi Circuit kuantum. Ini boleh meningkatkan overhed klasik, dan dalam sesetengah kes ia mungkin tidak mengubah kedalaman litar. Nilai lalai 2 secara umum menghasilkan litar terkecil dan agak pantas.

Tahap 0: Pengoptimuman Circuit DCQO yang terurai (susun atur, penghalaan, penjadualan)
Tahap 1: Pengoptimuman PauliEvolutionGate kemudian Circuit DCQO yang terurai (max_trials=10)
Tahap 2: Pengoptimuman PauliEvolutionGate kemudian Circuit DCQO yang terurai (max_trials=15)
Tahap 3: Pengoptimuman PauliEvolutionGate kemudian Circuit DCQO yang terurai (max_trials=20)
Tahap 4: Pengoptimuman PauliEvolutionGate kemudian Circuit DCQO yang terurai (max_trials=25)
Tahap 5: Pengoptimuman PauliEvolutionGate kemudian Circuit DCQO yang terurai (max_trials=50)

Tahap Pasca-pemprosesan (0-2): Kawal sejauh mana pengoptimuman klasik, mengimbangi ralat pembalikan bit dengan bilangan lintasan tamak carian tempatan yang berbeza:

Tahap 0: 1 lintasan
Tahap 1: 2 lintasan
Tahap 2: 3 lintasan

Mod transpilasi sahaja: Kini tersedia untuk pengguna yang ingin menganalisis pengoptimuman Circuit tanpa menjalankan pelaksanaan algoritma kuantum penuh.

Contoh konfigurasi tersuai: Berikut adalah cara anda boleh mengkonfigurasi Iskay dengan tetapan yang berbeza:

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

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,  # Using higher transpilation level for circuit optimization
    "seed_transpiler": 42,  # Fixed seed for reproducible results
    "job_tags": ["custom_config"],  # Custom tracking tags
}

Pengoptimuman benih: Perhatikan bahawa seed_transpiler ditetapkan kepada None secara lalai. Ini membolehkan proses pengoptimuman automatik Transpiler. Apabila None, sistem akan memulakan percubaan dengan beberapa benih dan memilih yang menghasilkan kedalaman Circuit terbaik, memanfaatkan sepenuhnya parameter max_trials untuk setiap tahap transpilasi.

Prestasi tahap transpilasi: Meningkatkan bilangan max_trials dengan nilai yang lebih tinggi untuk transpilation_level tidak dapat tidak akan meningkatkan masa transpilasi, tetapi ia mungkin tidak sentiasa mengubah litar akhir — ini sangat bergantung pada struktur dan kerumitan Circuit tertentu. Walau bagaimanapun, untuk sesetengah Circuit/masalah, perbezaan antara 10 percubaan (tahap 1) dan 50 percubaan (tahap 5) boleh menjadi dramatik, jadi meneroka parameter ini mungkin menjadi kunci untuk berjaya mencari penyelesaian.

Output

Nama	Jenis	Penerangan	Contoh
result	`Dict[str, Any]`	Penyelesaian dan metadata. Struktur berbeza bergantung pada pilihan `transpile_only`.	Lihat "Kandungan kamus keputusan" di bawah

Kandungan kamus keputusan

Struktur kamus keputusan bergantung pada mod pelaksanaan:

Medan	Jenis	Mod	Penerangan	Contoh
solution	`Dict[str, int]`	Standard	Penyelesaian terpetakan yang diisih di mana kunci ialah indeks pemboleh ubah (sebagai rentetan) diisih secara berangka dan nilai ialah nilai pemboleh ubah yang sepadan (1/-1 untuk masalah spin, 1/0 untuk masalah binari).	`{'0': -1, '1': -1, '2': -1, '3': 1, '4': 1}`
solution_info	`Dict[str, Any]`	Standard	Maklumat terperinci tentang penyelesaian (lihat butiran di bawah)	`{'bitstring': '11100', 'cost': -13.8, 'seed_transpiler': 42, 'mapping': {0: 0, 1: 1, 2: 2, 3: 3, 4: 4}}`
prob_type	`str`	Standard	Jenis masalah pengoptimuman ('spin' atau 'binary')	`'spin'`
transpilation_info	`Dict[str, Any]`	Transpilasi sahaja	Analisis Circuit dan butiran transpilasi (lihat butiran di bawah)	`{'best_seed': 42, 'transpilation_time_seconds': 50.06, 'transpiled_circuit': {'depth': 576, 'gate_count': 4177, 'num_qubits': 156, 'width': 176, 'operations': {'sx': 1325, 'rx': 891, 'cz': 783, 'rz': 650, 'rzz': 466, 'x': 42, 'measure': 20}}}`

Pelaksanaan standard

Apabila parameter pilihan transpile_only=False:

Kamus solution_info:

"bitstring" (str): Perwakilan bitstring mentah penyelesaian.
"cost" (float): Nilai kos/tenaga yang dikaitkan dengan penyelesaian.
"seed_transpiler" (int): Benih rawak yang digunakan untuk Transpiler yang menghasilkan keputusan ini.
"mapping" (Dict[int, int]): Pemetaan qubit-ke-pemboleh ubah asal yang digunakan dalam pengiraan.
"qpu_time" (float, pilihan): Masa pelaksanaan QPU dalam saat.

Nota pemetaan pemboleh ubah:

Kamus solution diperoleh daripada bitstring penyelesaian, menggunakan objek mapping untuk pengindeksan pemboleh ubah.
Apabila problem_type=spin kita menggunakan penugasan $1 \rightarrow -1, \quad 0 \rightarrow 1$ .
Kunci dalam kamus penyelesaian ialah indeks pemboleh ubah yang diisih secara berangka sebagai rentetan.

Analisis transpilasi

Apabila parameter pilihan transpile_only=True:

Kamus transpilation_info:

"best_seed" (int): Benih optimum yang ditemui untuk transpilasi
"transpilation_time_seconds" (float): Masa yang diambil untuk proses transpilasi
"transpiled_circuit" (Dict): Analisis Circuit yang mengandungi:
- "depth" (int): Kedalaman Circuit (bilangan lapisan)
- "gate_count" (int): Jumlah bilangan get dalam Circuit
- "num_qubits" (int): Bilangan qubit yang digunakan
- "width" (int): Lebar Circuit
- "operations" (Dict[str, int]): Kiraan setiap jenis get yang digunakan

Penggunaan mod transpilasi sahaja:

Tersedia untuk pengguna yang ingin menganalisis pengoptimuman Circuit tanpa menjalankan pelaksanaan algoritma kuantum penuh.
Berguna untuk analisis Circuit, kajian pengoptimuman kedalaman, dan memahami kesan transpilasi sebelum melakukan pelaksanaan penuh.

Mula

Dalam dokumentasi ini, kita akan melalui langkah-langkah menggunakan Iskay Quantum Optimizer. Dalam proses ini kita akan menunjukkan secara ringkas cara memuatkan fungsi daripada katalog dan cara menukar masalah anda kepada input yang sah, sambil menunjukkan cara anda boleh bereksperimen dengan parameter pilihan yang berbeza.

Untuk contoh yang lebih terperinci, sila semak tutorial Selesaikan masalah Market Split dengan Iskay Quantum Optimizer Kipu Quantum, di mana kita melalui keseluruhan proses menggunakan Iskay Solver untuk menangani masalah Market Split, yang mewakili cabaran peruntukan sumber dunia sebenar di mana pasaran mesti dibahagikan kepada wilayah jualan yang seimbang untuk memenuhi sasaran permintaan tepat.

Sahkan menggunakan kunci API anda, yang boleh didapati pada papan pemuka IBM Quantum Platform, dan pilih Fungsi Qiskit seperti berikut:

# ruff: noqa: F821

nota

Kod berikut mengandaikan bahawa anda telah menyimpan bukti kelayakan anda. Jika belum, ikuti arahan dalam simpan akaun IBM Cloud anda untuk mengesahkan dengan kunci API anda.

from qiskit_ibm_catalog import QiskitFunctionsCatalog

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

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

Contoh 1: Fungsi kos mudah

Pertimbangkan fungsi kos 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$ .

Penyelesaian kepada fungsi kos mudah ini ialah

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

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

1. Cipta fungsi objektif

Kita mulakan dengan mencipta kamus dengan pekali fungsi objektif seperti 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 Pengoptimum

Kita selesaikan masalah dengan menjalankan pengoptimum. Oleh kerana $(x_0, ..., x_4) \in \{-1, 1\}^5$ kita mesti menetapkan 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. Dapatkan keputusan

Penyelesaian masalah pengoptimuman diberikan terus daripada pengoptimum.

print(job.result())

Ini akan memaparkan kamus dalam 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 bahawa kamus solution memaparkan vektor keputusan $(x_0, x_1, x_2, x_3, x_4) = (-1, -1, -1, 1, 1)$ .

Contoh 2: MaxCut

Banyak masalah graf seperti MaxCut atau set bebas maksimum ialah masalah NP-susah dan calon ideal untuk menguji algoritma kuantum dan perkakasan. Contoh ini menunjukkan penyelesaian masalah MaxCut bagi graf 3-sekata dengan Pengoptimum Kuantum.

Untuk menjalankan contoh ini anda mesti memasang pakej networkx selain daripada qiskit-ibm-catalog. Untuk memasangnya, jalankan arahan berikut:

# %pip install networkx numpy

1. Cipta fungsi objektif

Mulakan dengan menjana graf 3-sekata rawak. Untuk graf ini, kita takrifkan fungsi objektif 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 Pengoptimum

Selesaikan masalah dengan menjalankan pengoptimum.

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

Dapatkan keputusan dan petakan semula bitstring penyelesaian ke nod graf asal.

print(job.result())

Penyelesaian kepada masalah Maxcut terkandung terus dalam sub-kamus solution objek keputusan

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

Contoh 3: Contoh penanda aras

Contoh penanda aras tersedia di GitHub: Contoh penanda aras Kipu.

Contoh boleh dimuatkan menggunakan pustaka pygithub. Untuk memasangnya, jalankan arahan berikut:

# %pip install pygithub

Laluan untuk contoh penanda aras ialah:

Maxcut:

'maxcut/maxcut_28_nodes.json'
'maxcut/maxcut_30_nodes.json'
'maxcut/maxcut_32_nodes.json'
'maxcut/maxcut_80_nodes.json'
'maxcut/maxcut_100_nodes.json'
'maxcut/maxcut_120_nodes.json'

HUBO:

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

Untuk menghasilkan semula prestasi penanda aras bagi contoh HUBO, pilih Backend ibm_marrakesh dan tetapkan direct_qubit_mapping kepada True dalam sub-kamus options.

Contoh berikut menjalankan contoh Maxcut dengan 32 nod.

from github import Github
import urllib
import json
import ast

repo = "Kipu-Quantum-GmbH/benchmark-instances"
path = "maxcut/maxcut_32_nodes.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": "ibm_brisbane",
    "options": options,
}

job = optimizer.run(**arguments)

result = job.result()

Kes penggunaan

Kes penggunaan tipikal untuk penyelesai Pengoptimuman ialah masalah pengoptimuman kombinatori. Anda boleh menyelesaikan masalah daripada banyak industri seperti kewangan, farmaseutik, atau logistik. Beberapa contoh berikut:

Pengoptimuman portfolio (QUBO): penerbitan saintifik dan kertas putih
Pelipatan protein (HUBO): penerbitan saintifik
Penjadualan logistik (QUBO): penerbitan saintifik
Pengoptimuman rangkaian: webinar
Pembahagian pasaran (QUBO): tutorial

Jika anda berminat untuk menangani kes penggunaan tertentu dan membangunkan pemetaan khusus, kami boleh membantu anda. Hubungi kami.

Dapatkan sokongan

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

Langkah seterusnya

Maklumat tambahan

Iskay, seperti nama syarikat kami Kipu Quantum, ialah perkataan Peru. Walaupun kami ialah syarikat permulaan dari Jerman, perkataan-perkataan ini berasal dari negara asal salah seorang pengasas bersama kami, di mana Quipu ialah salah satu mesin pengiraan pertama yang dibangunkan oleh manusia 2000 tahun SM.

Source: IBM Quantum docs — updated 5 Mei 2026

English version on doQumentation — updated 7 Mei 2026

This translation based on the English version of 11 Mac 2026

Gambaran keseluruhan​

Penerangan​

Bagaimana Pengoptimum Kuantum berfungsi?​

Alur kerja​

Penanda aras​

Input dan output​

Input​

Format masalah yang diterima​

Pilihan​

Output​

Kandungan kamus keputusan​

Pelaksanaan standard​

Analisis transpilasi​

Mula​

Contoh 1: Fungsi kos mudah​

1. Cipta fungsi objektif​

2. Jalankan Pengoptimum​

3. Dapatkan keputusan​

Contoh 2: MaxCut​

1. Cipta fungsi objektif​

2. Jalankan Pengoptimum​

3. Dapatkan keputusan​

Contoh 3: Contoh penanda aras​

Kes penggunaan​

Dapatkan sokongan​

Langkah seterusnya​

Maklumat tambahan​

Gambaran keseluruhan

Penerangan

Bagaimana Pengoptimum Kuantum berfungsi?

Alur kerja

Penanda aras

Input dan output

Input

Format masalah yang diterima

Pilihan

Output

Kandungan kamus keputusan

Pelaksanaan standard

Analisis transpilasi

Mula

Contoh 1: Fungsi kos mudah

1. Cipta fungsi objektif

2. Jalankan Pengoptimum

3. Dapatkan keputusan

Contoh 2: MaxCut

1. Cipta fungsi objektif

2. Jalankan Pengoptimum

3. Dapatkan keputusan

Contoh 3: Contoh penanda aras

Kes penggunaan

Dapatkan sokongan

Langkah seterusnya

Maklumat tambahan