Menjalankan pekerjaan komputasi kuantum hibrid dengan profil adaptif target

Komputasi hibrid menggabungkan proses komputasi klasik dan kuantum untuk menyelesaikan masalah yang kompleks.

Dalam komputasi hibrid, kode klasik mengontrol eksekusi operasi kuantum berdasarkan pengukuran pertengahan sirkuit sementara qubit fisik tetap aktif. Anda dapat menggunakan teknik pemrograman umum, seperti kondisional berlapis, perulangan, dan panggilan fungsi, dalam satu program kuantum untuk menjalankan masalah kompleks, mengurangi jumlah bidikan yang diperlukan. Dengan teknik penggunaan kembali qubit, program yang lebih besar dapat berjalan pada mesin menggunakan jumlah qubit yang lebih kecil.

Artikel ini menjelaskan cara mengirimkan pekerjaan hibrid ke Azure Quantum menggunakan Adaptive RItarget profil. Profil ini Adaptive RItarget menawarkan dukungan untuk pengukuran sirkuit menengah, alur kontrol berbasis pengukuran, reset kubit, dan komputasi bilangan bulat klasik.

Prasyarat

Akun Azure dengan langganan aktif. Jika Anda tidak memiliki akun Azure, daftarkan secara gratis dan daftar untuk langganan prabayar.
Ruang kerja Azure Quantum. Untuk informasi selengkapnya, lihat Buat ruang kerja Azure Quantum.

Jika Anda ingin mengirimkan Q# program mandiri, maka Anda juga memerlukan prasyarat berikut:

Instal Visual Studio Code (VS Code).
Instal versi terbaru ekstensi MicrosoftQuantum Development Kit.

Jika Anda ingin mengirimkan Python dan Q# program, maka Anda juga memerlukan prasyarat berikut:

Lingkungan Python dengan Python dan Pip terinstal.
Paket Python terbaru qdk dengan tambahan opsionalazure.
```
pip install --upgrade "qdk[azure]"
```

Didukung targets

Untuk menjalankan pekerjaan komputasi kuantum hibrid, Anda perlu memilih penyedia kuantum yang mendukung Adaptive RItarget profil.

Saat ini, profil adaptif target di Azure Quantum didukung di Quantinuumtargets.

Mengirimkan pekerjaan adaptif untuk RI

Untuk mengirimkan pekerjaan komputasi kuantum hibrid, Anda perlu mengonfigurasi target profil sebagai Adaptive RI, di mana RI adalah singkatan dari "qubit Reset dan Integer computations".

Profil ini Adaptive RItarget menawarkan dukungan untuk pengukuran sirkuit menengah, alur kontrol berbasis pengukuran, reset kubit, dan komputasi bilangan bulat klasik.

Anda dapat mengirimkan pekerjaan kuantum hibrid ke Azure Quantum sebagai Q# program mandiri atau Python + Q# program. Untuk mengonfigurasi target profil untuk pekerjaan kuantum hibrid, lihat bagian berikut.

Q# di Visual Studio Code
Q#+ Python

Untuk mengonfigurasi target profil untuk pekerjaan hibrid di Visual Studio Code, pilih salah satu opsi berikut:

Jika file Q# Anda bukan bagian dari proyek Q#, buka file dan masukkan @EntryPoint(Adaptive_RI) sebelum operasi titik awal program Anda.
Jika file Anda Q# adalah bagian Q# dari proyek, tambahkan yang berikut ini ke file proyek qsharp.json Anda:
```
{
  "targetProfile": "adaptive_ri"
}
```

Saat mengatur target profil ke Adaptive RI, Anda dapat mengirimkan Q# program Anda sebagai pekerjaan kuantum hibrid ke Quantinuum. Untuk melakukannya, ikuti langkah-langkah berikut:

Buka menu Tampilan dan pilih Palet Perintah, masukkan QDK: Sambungkan ke ruang kerja Azure Quantum, lalu tekan Enter.
Pilih akun Azure, dan ikuti perintah untuk menyambungkan ke direktori, langganan, dan ruang kerja pilihan Anda.
Setelah tersambung, untuk melihat ruang kerja Azure Quantum Anda, pilih ikon panel Microsoft Quantum (kiri bawah).
Perluas ruang kerja Anda dan perluas penyedia Quantinuum .
Pilih Quantinuum apa pun yang tersedia target, misalnya quantinuum.sim.h2-1e.
Pilih ikon pemutar di sebelah kanan nama target untuk memulai pengiriman program saat ini Q#.
Masukkan nama untuk mengidentifikasi tugas, dan jumlah bidikan.
Tekan Enter untuk mengirimkan pekerjaan. Status pekerjaan ditampilkan di bagian bawah layar.
Perluas Pekerjaan dan arahkan mouse ke atas pekerjaan Anda, yang menampilkan waktu dan status pekerjaan Anda.

qdk Dengan paket Python, gunakan objek init dan TargetProfile untuk mengatur parameter target_profile ke Adaptive_RI.
```
from qdk import init, TargetProfile

init(target_profile=TargetProfile.Adaptive_RI)
```

Sambungkan ke ruang kerja Azure Quantum Anda.

from qdk.azure import Workspace

workspace = Workspace(resource_id="") # add your resource ID

Atur target parameter ke Quantinuum target yang ingin Anda gunakan. Misalnya, untuk menggunakan quantinuum.sim.h2-1etarget:
```
target = workspace.get_targets("quantinuum.sim.h2-1e")
```

Anda dapat menggabungkan beberapa pekerjaan kuantum hibrid dalam sesi menggunakan target.open_session fungsi . Untuk informasi selengkapnya, lihat Memulai dengan sesi.

Catatan

Meskipun sesi tersedia untuk semua penyedia perangkat keras komputasi kuantum, Adaptive_RItarget tugas profil saat ini hanya didukung di Quantinuum targets.

Fitur yang didukung

Tabel berikut mencantumkan fitur yang didukung untuk komputasi kuantum hibrid dengan Quantinuum di Azure Quantum.

Fitur yang didukung	Catatan
Nilai Dinamika	Bool dan bilangan bulat yang nilainya bergantung pada hasil pengukuran
Perulangan	Perulangan yang dibatasi secara klasik saja
Alur kontrol semena-mena	Penggunaan percabangan if/else
Pengukuran sirkuit tengah	Menggunakan sumber daya register klasik
Penggunaan kembali qubit	Didukung
Komputasi real-time klasik	Aritmatika bilangan bulat bertanda tangan 64-bit, menggunakan sumber daya register klasik

QDK memberikan targetumpan balik khusus saat Q# fitur bahasa tidak didukung untuk yang dipilih target. Jika program Anda Q# berisi fitur yang tidak didukung saat menjalankan pekerjaan kuantum hibrid, maka Anda menerima pesan kesalahan pada waktu desain. Untuk informasi selengkapnya, lihat QIR halaman wiki.

Catatan

Anda perlu memilih profil yang sesuai Adaptive RItarget untuk mendapatkan umpan balik yang sesuai saat Anda menggunakan Q# fitur yang target tidak didukung.

Untuk melihat fitur yang didukung dalam tindakan, salin kode berikut ke dalam Q# file dan tambahkan cuplikan kode berikutnya.

import Std.Measurement.*;
import Std.Math.*;
import Std.Convert.*;

operation Main() : Result {
    use (q0, q1) = (Qubit(), Qubit());
    H(q0);
    let r0 = MResetZ(q0);

    // Copy here the code snippets below to see the supported features 
    // in action.
    // Supported features include dynamic values, classically-bounded loops, 
    // arbitrary control flow, and mid-circuit measurement.

    r0
}

Quantinuum mendukung bool dan bilangan bulat dinamis, yang berarti bool dan bilangan bulat yang bergantung pada hasil pengukuran. Perhatikan bahwa r0 adalah Result jenis yang dapat digunakan untuk menghasilkan nilai bool dan bilangan bulat dinamis.

    let dynamicBool = r0 != Zero; 
    let dynamicBool = ResultAsBool(r0); 
    let dynamicInt = dynamicBool ? 0 | 1;

Quantinuum mendukung bool dan bilangan bulat dinamis, namun, quantinuum tidak mendukung nilai dinamis untuk jenis data lain, seperti ganda. Salin kode berikut untuk melihat umpan balik tentang batasan nilai dinamis.

    let dynamicDouble = r0 == One ? 1. | 0.; // cannot use a dynamic double value
    let dynamicInt = r0 == One ? 1 | 0;
    let dynamicDouble = IntAsDouble(dynamicInt); // cannot use a dynamic double value
    let dynamicRoot = Sqrt(dynamicDouble); // cannot use a dynamic double value

Meskipun nilai dinamis tidak didukung untuk beberapa jenis data, jenis data tersebut masih dapat digunakan dengan nilai statis.

    let staticRoot = Sqrt(4.0);
    let staticBigInt = IntAsBigInt(2);

Bahkan nilai dinamis dari tipe data yang didukung tidak dapat digunakan dalam situasi tertentu. Misalnya, Quantinuum tidak mendukung array dinamis, yaitu array yang ukurannya tergantung pada hasil pengukuran. Quantinuum juga tidak mendukung perulangan yang terikat secara dinamis. Salin kode berikut untuk melihat batasan nilai dinamis.

    let dynamicInt = r0 == Zero ? 2 | 4;
    let dynamicallySizedArray = [0, size = dynamicInt]; // cannot use a dynamically-sized array
    let staticallySizedArray = [0, size = 10];
    // Loops with a dynamic condition are not supported by Quantinuum.
    for _ in 0..dynamicInt {
         Rx(PI(), q1);
    }
        
    // Loops with a static condition are supported.
    let staticInt = 3;
    for _ in 0..staticInt {  
         Rx(PI(), q1);  
    }

Quantinuum mendukung alur kontrol, termasuk if/else percabangan, menggunakan kondisi statis dan dinamis. Percabangan pada kondisi dinamis juga dikenal sebagai percabangan berdasarkan hasil pengukuran.

    let dynamicInt = r0 == Zero ? 0 | 1; 
    if dynamicInt > 0 {
        X(q1);
     }
    let staticInt = 1;
    if staticInt > 5 {
         Y(q1);
    } else {
         Z(q1);
    }

Quantinuum mendukung perulangan dengan kondisi klasik dan termasuk ekspresi seperti if.

    for idx in 0..3 {
        if idx % 2 == 0 {
            Rx(ArcSin(1.), q0);
            Rz(IntAsDouble(idx) * PI(), q1)
        } else {
            Ry(ArcCos(-1.), q1);
             Rz(IntAsDouble(idx) * PI(), q1)
        }
     }

Quantinuum mendukung pengukuran pertengahan sirkuit, yaitu percabangan berdasarkan hasil pengukuran.

    if r0 == One {
        X(q1);
    }
    let r1 = MResetZ(q1);
    if r0 != r1 {
        let angle = PI() + PI() + PI()* Sin(PI()/2.0);
        Rxx(angle, q0, q1);
    } else {
        Rxx(PI() + PI() + 2.0 * PI() * Sin(PI()/2.0), q1, q0);
    }

Memperkirakan biaya pekerjaan komputasi kuantum hibrid

Anda dapat memperkirakan biaya untuk menjalankan pekerjaan komputasi kuantum hibrid pada perangkat keras Quantinuum dengan menjalankan pekerjaan pada emulator terlebih dahulu.

Setelah berhasil dijalankan pada emulator:

Di ruang kerja Azure Quantum Anda, pilih Manajemen pekerjaan.
Pilih pekerjaan yang Anda kirimkan.
Dalam pop-up detail pekerjaan, pilih Estimasi Biaya untuk melihat jumlah eHQC (kredit emulator Quantinuum) yang digunakan. Jumlah ini diterjemahkan langsung ke jumlah HQC (kredit kuantum Quantinuum) yang diperlukan untuk menjalankan pekerjaan pada perangkat keras Quantinuum.

Perkiraan biaya

Catatan

Quantinuum mengurai seluruh sirkuit dan menghitung biaya pada semua jalur kode, baik dieksekusi secara kondisional atau tidak.

Contoh komputasi kuantum hibrida

Sampel berikut dapat ditemukan di Q# repositori sampel kode. Mereka menunjukkan set fitur saat ini untuk komputasi kuantum hibrid.

Kode pengulangan tiga kubit

Sampel ini menunjukkan cara membuat kode pengulangan tiga kubit yang dapat digunakan untuk mendeteksi dan memperbaiki kesalahan balik bit.

Ini memanfaatkan fitur komputasi hibrid terintegrasi untuk menghitung berapa kali koreksi kesalahan dilakukan saat status register kubit logis koheren.

Anda dapat menemukan kode dalam sampel ini.

Estimasi fase berulang

Program sampel ini menunjukkan estimasi fase iteratif dalam Q#. Ini menggunakan estimasi fase iteratif untuk menghitung produk internal antara dua vektor 2 dimensi yang dikodekan pada target qubit dan qubit ancilla. Kubit kontrol tambahan juga diinisialisasi yang merupakan satu-satunya kubit yang digunakan untuk pengukuran.

Sirkuit dimulai dengan mengode pasangan vektor pada qubit target dan qubit ancilla. Kemudian menerapkan operator Oracle ke seluruh register, dikendalikan oleh qubit kontrol, yang diatur dalam keadaan $\ket +$. Operator Oracle yang dikontrol menghasilkan fase pada status $\ket 1$ dari qubit kontrol. Ini kemudian dapat dibaca dengan menerapkan gerbang H ke kubit kontrol untuk membuat fase dapat diamati saat mengukur.

Anda dapat menemukan kode dalam sampel ini.

Catatan

Kode sampel ini ditulis oleh anggota tim KPMG Quantum di Australia dan termasuk dalam Lisensi MIT. Ini menunjukkan kemampuan Adaptive RItargets yang diperluas dan menggunakan perulangan terikat, panggilan fungsi klasik pada waktu proses, pernyataan kondisional berlapis, pengukuran sirkuit tengah, dan penggunaan kembali qubit.

Memulai sesi

Saran dan Komentar

Apakah halaman ini membantu?

Last updated on 2026-04-29

Menjalankan pekerjaan komputasi kuantum hibrid dengan profil adaptif target

Prasyarat

Didukung targets

Mengirimkan pekerjaan adaptif untuk RI

Fitur yang didukung

Memperkirakan biaya pekerjaan komputasi kuantum hibrid

Contoh komputasi kuantum hibrida

Kode pengulangan tiga kubit

Estimasi fase berulang

Konten terkait

Saran dan Komentar

Sumber Daya Tambahan: