Parity Twine Optimizer: Fungsi Qiskit oleh ParityQC

Lihat rujukan API

nota

Qiskit Functions ialah ciri eksperimen yang hanya tersedia untuk pengguna Pelan Premium, Pelan Flex, dan Pelan On-Prem (melalui IBM Quantum Platform API) IBM Quantum®. Ia berstatus keluaran pratonton dan tertakluk kepada perubahan.

Gambaran Keseluruhan

Parity Twine Optimizer membolehkan pengguna menyelesaikan masalah pengoptimuman dengan komputer kuantum menggunakan kaedah Parity Twine. Pendekatan ini, dibina berasaskan Parity Architecture, menggunakan pengkompil ParityQC untuk meminimumkan bilangan get dan kedalaman litar yang diperlukan untuk menjalankan algoritma kuantum sambil mengambil kira ketersambungan peranti.

Pengurangan sumber ini membolehkan penyelesaian masalah pengoptimuman yang relevan dengan industri untuk saiz yang tidak boleh dilaksanakan dengan kaedah transpilasi standard yang banyak bergantung pada get SWAP. Parity Twine Optimizer mengautomasikan langkah transpilasi dan boleh digunakan dengan input pengguna yang minimum.

Pendekatan Parity Twine mengatasi semua kaedah kompilasi lain dari segi pengurangan bilangan get dan kedalaman litar untuk algoritma kuantum seperti quantum approximate optimization algorithm (QAOA) dan quantum Fourier transform (QFT). Dengan mengabstrakkan maklumat kuantum daripada qubit fizikal, interaksi bukan setempat dilaksanakan tanpa get SWAP. Sebaliknya, rantai Parity Twine (jujukan get CNOT) mengagihkan maklumat pariti logik secara sistematik antara qubit.

Pengoptimum menggunakan QAOA untuk meminimumkan tenaga bagi fungsi kos yang diberikan. QAOA ialah algoritma variasi hibrid kuantum-klasik yang direka untuk menyelesaikan masalah pengoptimuman kombinatorik dengan menghampiri keadaan asas bagi Hamiltonan kos ($H_C$). Terma percampuran ($H_B$) memacu peralihan antara keadaan untuk meneroka ruang penyelesaian. Jujukan berselang-seli bagi terma-terma ini, dikawal oleh parameter $\gamma$ dan $\beta$, mentakrifkan unitari $U(\gamma, \beta) = \Pi_{i=1}^p e^{-i \beta_i H_B} e^{-i \gamma_i H_C}$, yang bertindak ke atas keadaan awal.

Pengekodan unitari masalah, exp($-i \beta H_C)$), memerlukan pengekodan semua operator putaran $n$-body logik (exp($-i \beta J_{i,j,...n}Z_iZ_j...Z_n$)). Ini boleh dicapai dengan menggunakan penjana $n$-body (Rangkaian Parity Twine), yang mengurangkan kedalaman litar QAOA dan bilangan get dua-qubit.

Penerangan

Input Parity Twine Optimizer terdiri daripada masalah pengoptimuman, nama perkakasan IBM Quantum yang dipilih, dan argumen pilihan tambahan untuk menyesuaikan tetapan transpilasi dan pelaksanaan perkakasan. Fungsi pengoptimum menghalakan takrifan masalah kepada Parity Twine Compiler. Rajah 1 menunjukkan ringkasan aliran kerja fungsi.

Masalah pengoptimuman input diprapemproses menjadi Hamiltonan (ternormal). Pengkompil ParityQC kemudian membina litar ansatz Parity Twine berparameter, yang ditranspilkan kepada ansatz logik yang sepadan dengan set get asli perkakasan yang dipilih.

Parameter litar QAOA dioptimumkan secara klasik menggunakan pendekatan "efficient depth one" dan ditetapkan kepada litar yang telah ditranspilkan. Memandangkan satu pusingan QAOA digunakan, parameter $\gamma$ dan $\beta$ yang optimum diperoleh menggunakan carian grid pada CPU tanpa memerlukan pengoptimuman berulang yang mahal merentasi banyak panggilan litar. Ini meminimumkan dengan ketara masa jalan QPU yang diperlukan oleh pengoptimum. Masa pelaksanaan bagi setiap litar sebahagian besarnya ditentukan oleh overhed tetap untuk menjalankan kerja pada QPU. Dengan parameter litar ditetapkan, kerja dihantar ke QPU IBM® yang ditentukan.

Hasil mentah kemudian dipasca-proses. Langkah ini menggunakan carian tamak (greedy) tempatan yang melalui rentetan penyelesaian secara rawak dan menterbalikkan nilai bit jika ini mengurangkan nilai fungsi kos.

Penanda Aras

Penafian

Prestasi boleh bergantung kepada kedua-dua instans masalah dan langkah pemprosesan seterusnya. Dalam sesetengah kes, sampel klasik dan sampel yang dijana secara kuantum mungkin mencapai kualiti penyelesaian akhir yang serupa selepas pasca-pemprosesan yang setara. Oleh itu, penilaian harus mempertimbangkan keseluruhan aliran kerja pengoptimuman.

Model Sherrington-Kirkpatrick

Rajah 2 menunjukkan keberkesanan Parity Twine Optimizer. Ini membandingkan hasil yang diperoleh menggunakan pengoptimum dengan pensampelan rawak untuk model Sherrington-Kirkpatrick dengan bilangan qubit yang semakin meningkat.

Pasca-pemprosesan bagi kedua-dua hasil rawak dan hasil pengoptimum membawa kepada keadaan asas yang tepat, tetapi output tenaga minimum mentah daripada Twine QAOA sentiasa lebih baik daripada nilai rawak. Untuk bilangan qubit terbesar yang dipertimbangkan (90 dan 100), hingar perkakasan menjejaskan hasil pengoptimum sehingga ia kembali kepada nilai mentah yang sepadan dengan pensampelan rawak.

Lihat tutorial ini untuk pengenalan kepada model Sherrington-Kirkpatrick dan butiran mengenai cara menyelesaikannya dengan Parity Twine Optimizer.

Masalah Market Split

Jadual 1 menunjukkan metrik prestasi khusus untuk Parity Twine Optimizer yang digunakan pada pelbagai instans masalah Market Split (MS). Ini diperoleh daripada QOBLIB - Quantum Optimization Benchmarking Library dan sepadan dengan penyerahan yang dibuat ke perpustakaan menggunakan Parity Twine Optimizer.

Pelanggaran MS ialah metrik ketepatan yang mengukur sejauh mana penyelesaian itu menyimpang daripada memenuhi semua kekangan, ditakrifkan sebagai $\sum_i ((Ax - b)_i)^2$. Nilai metrik ini yang lebih rendah menunjukkan penyelesaian yang lebih tepat. Jadual 1 melaporkan nilai purata untuk lima larian bagi setiap instans menggunakan Parity Twine Optimizer dengan peranti ibm_boston sebagai backend dan 100,000 shot (cubaan pengukuran). Pelanggaran MS minimum yang diperoleh daripada larian setiap instans dilaporkan.

Instans	Qubit	Get dua-qubit	Kedalaman dua-qubit	Pelanggaran MS	Masa pemetaan (s)	Masa jalan QPU (s)	Masa pasca-proses (s)
ms_03_050_002	20	399	76	0	45	29	71
ms_03_100_022	20	399	76	0	30	29	77
ms_03_200_177	20	399	76	0	33	29	63
ms_04_050_001	30	899	116	1	68	29	216
ms_04_100_003	30	899	116	2	89	29	187
ms_04_200_030	30	899	116	3	89	29	219
ms_05_100_003	40	1599	156	3	237	30	364
ms_06_050_001	50	2499	196	4	499	30	464
ms_07_050_001	60	3599	236	17	858	31	637
ms_08_050_001	70	4899	276	36	1561	31	773

Jadual 1: Metrik prestasi untuk pelbagai instans masalah market split. Nama instans adalah untuk contoh yang berkaitan dalam perpustakaan masalah QOBLIB. Seperti yang disebut sebelum ini dalam bahagian penerangan, masa QPU adalah minimum dan hampir malar, kerana hanya satu pusingan QAOA digunakan dengan parameter litar optimum yang diperoleh pada CPU.

Lihat tutorial ini untuk pengenalan kepada masalah Market Split dan butiran mengenai cara menyelesaikannya dengan Parity Twine Optimizer.

Masalah Maximum Independent Set

Rajah 3 membandingkan hasil yang diperoleh menggunakan pengoptimum Parity Twine dengan pensampelan rawak untuk masalah maximum independent set bagi instans terpilih yang diperoleh daripada QOBLIB - Quantum Optimization Benchmarking Library. Ini terdiri daripada 18 (mammalia-kangaroo-interactions) hingga 114 (es60fst03) qubit.

Untuk instans kecil, hasil saiz Maximum Independent Set mentah daripada pengoptimum dan pensampelan rawak adalah serupa, tetapi untuk instans yang lebih besar, pengoptimum memberikan hasil yang jauh lebih baik. Pasca-pemprosesan bagi kedua-dua hasil pensampelan rawak dan hasil pengoptimum sekali lagi membawa kepada saiz set yang selaras dengan nilai tepat.

Mula

Sahkan diri anda menggunakan token API IBM Quantum Platform anda dan pilih Fungsi Qiskit sebagai:

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"qiskit_ibm_catalog": "qiskit-ibm-catalog"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

from qiskit_ibm_catalog import QiskitFunctionsCatalog

# Authenticate and load the Qiskit Function
catalog = QiskitFunctionsCatalog(
    channel="ibm_quantum_platform",
)
function = catalog.load("parityqc/parity-twine-optimizer")

Contoh

Parity Twine Optimizer boleh digunakan pada contoh QUBO mudah seperti berikut. Masalah ini mula-mula ditakrifkan dengan menggunakan kamus:

problem = {"()": 3, "(0,)": 1, "(0, 1)": 2, "(1, 2)": -1}

Kemudian, jenis pemboleh ubah perlu ditakrifkan sebagai binary atau spin:

variable_type = "spin"

Ini mentakrifkan fungsi objektif $3 + s_0 + 2 s_0s_1 - s_1s_2$ dengan $s_i \in \{-1, 1\}$.

Pilih backend. Contohnya:

backend_name = "ibm_phoenix"

Gunakan catalog.backends() untuk melihat senarai backend yang tersedia daripada akaun/instans pengguna.

Jika tiada backend dinyatakan, backend yang paling kurang sibuk (iaitu yang mempunyai bilangan kerja tertangguh yang paling sedikit) dipilih secara automatik.

Setelah pengoptimum dimuatkan (lihat sebelumnya), anda boleh menjalankannya pada masalah menggunakan pilihan lalai:

function_job = function.run(
    problem=problem, variable_type=variable_type, backend_name=backend_name
)
print(f"Job ID: {function_job.job_id}")

Semak status kerja seperti berikut:

# Monitor the job status
function_job.status()

Dapatkan hasil seperti berikut:

# Retrieve the job result if the status is DONE
result = function_job.result()

result

Mencetak hasil memberikan yang berikut:

{
    'solution': {'0': -1, '1': 1, '2': 1},
    'objective_value': -1.0,
    'solution_bitstring': '100',
    'metadata': {
        'circuit_metrics': {
            'depth': 20,
            'gate_count': 198,
            'two_qubit_gate_depth': 4,
            'two_qubit_gate_count': 4,
            'num_qubits': 3,
            'operations': {'delay': 158, 'rz': 17, 'sx': 14, 'cz': 4, 'measure': 3, 'x': 2}
        },
        'solver_info': {
            'variable_mapping': {'0': 0, '1': 1, '2': 2},
            'bitstring_distributions': {
                'before_postprocessing': {'100': 71760, ... },
                'after_postprocessing': {'100': 88440, '011': 11560}
            },
            'best_parameters': {
                'beta': [-0.46259546391008877],
                'gamma': [0.6181957189727373]
            }
        },
        'resource_usage': {
            'RUNNING: MAPPING': {'CPU_TIME': 42.878},
            'RUNNING: OPTIMIZING_FOR_HARDWARE': {'CPU_TIME': 0.094},
            'RUNNING: WAITING_FOR_QPU': {'CPU_TIME': 790.623},
            'RUNNING: EXECUTING_QPU': {'QPU_TIME': 28.0},
            'RUNNING: POST_PROCESSING': {'CPU_TIME': 0.828}
        }
    }
}

Kamus solution sepadan dengan qubit yang ditakrifkan dalam masalah ($s_0, s_1$, dan $s_2$) dan memberikan nilai spin yang dioptimumkan bagi setiap satu.

objective_value ialah kos atau tenaga bagi masalah pengoptimuman. Ia mengukur kualiti solution.

metadata memberikan maklumat mengenai transpilasi (bilangan/kedalaman get dua-qubit, get yang digunakan, qubit aktif) dan pelbagai masa jalan untuk kedua-dua masa pengkomputeran kuantum dan klasik.

Selain itu, metadata memberikan gambaran ke dalam cara kerja dalaman algoritma. Anda boleh melihat parameter variasi yang dioptimumkan (beta dan gamma) dan menyemak bagaimana taburan rentetan bit (bitstring) yang diukur bertambah baik selepas pasca-pemprosesan klasik diterapkan pada hasil kuantum mentah.

Semua rentetan bit dalam output hasil boleh dipetakan kepada pemboleh ubah masalah dengan menggunakan variable_mapping. Sebagai contoh, anda boleh memetakan 'solution_bitstring': '100' dengan 'variable_mapping': {'0': 0, '1': 1, '2': 2} kepada penyelesaian binari: {'0': 1, '1': 0, '2': 0}. Memandangkan anda menyelesaikan masalah dari segi pemboleh ubah spin, anda perlu menerapkan transformasi binari kepada spin (0 -> 1, 1 -> -1 ). Anda kemudian akan sampai kepada penyelesaian akhir 'solution': {'0': -1, '1': 1, '2': 1}.

Rujuk rujukan API untuk butiran lengkap input kepada dan output daripada fungsi Parity Twine Optimizer.

Log perubahan

[1.0.2] - 2026-09-15

Notes

Keluaran ini menandakan versi pengeluaran stabil pertama bagi Fungsi Qiskit Parity Twine Optimizer. Keluaran akan datang dijangka memperkenalkan yang berikut:

• kompilasi masalah tertib lebih tinggi,
• algoritma pengoptimuman tambahan, dan
• penambahbaikan dalam pra- dan pasca-pemprosesan.

Ciri

• Selesaikan masalah QUBO jarang dan padat dengan Parity Twine Compiler yang cekap.

Dokumentasi

• Panduan pengguna permulaan.
• Tutorial dengan contoh untuk masalah Market Split dan Sherrington-Kirkpatrick.
• Dokumentasi API.

Dapatkan sokongan

Hubungi ParityQC jika ada sebarang soalan atau isu.

Langkah seterusnya

Cadangan

• Minta akses kepada fungsi ini dengan melengkapkan borang ini.
• Lawati rujukan API untuk Fungsi Qiskit ini.
• Cuba tutorial ini untuk menggunakan Parity Twine Optimizer bagi masalah Market Split.
• Cuba tutorial ini untuk menggunakan Parity Twine Optimizer bagi model Sherrington-Kirkpatrick.
• Semak semula praprint ArXiv Connectivity-aware Synthesis of Quantum Algorithms, Drier et al. (2025).