Komputasi hibrid terintegrasi

Komputasi hibrid terintegrasi menyatukan proses klasik dan kuantum, memungkinkan kode klasik mengontrol eksekusi operasi kuantum berdasarkan pengukuran pertengahan sirkuit sementara qubit fisik tetap hidup. Menggunakan teknik pemrograman umum, seperti kondisional berlapis, perulangan, dan panggilan fungsi, satu program kuantum dapat menjalankan masalah kompleks, mengurangi jumlah bidikan yang diperlukan. Menggunakan teknik penggunaan kembali qubit, program yang lebih besar dapat berjalan pada mesin yang menggunakan jumlah qubit yang lebih kecil.

Untuk diskusi selengkapnya, lihat:

• Granade & Weibe, "Menggunakan Jalan Acak untuk Estimasi Fase Berulang".
• Lubinski, et al., "Memajukan Hybrid Quantum–Komputasi Klasik dengan Eksekusi Real Time"

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, Anda memerlukan prasyarat berikut:
  • Visual Studio Code dengan ekstensi Azure Quantum Development Kit terinstal.
  • Versi terbaru ekstensi Azure Quantum Development Kit .
• Jika Anda ingin mengirimkan Python + Q# program, Anda memerlukan prasyarat berikut:

  • Lingkungan Python dengan Python dan Pip terinstal.

  • Azure Quantum azure-quantum dan qsharp paket.

    pip install --upgrade azure-quantum qsharp
    

Didukung targets

Saat ini, model komputasi hibrid terintegrasi di Azure Quantum didukung di Quantinuumtargets.

Mengirimkan pekerjaan hibrid terintegrasi

Saat mengirimkan pekerjaan hibrid terintegrasi, Anda perlu mengonfigurasi target profil sebagai QIR Adaptive RI. Profil ini QIR Adaptive RItarget menawarkan dukungan untuk pengukuran sirkuit menengah, alur kontrol berbasis pengukuran, reset kubit, dan komputasi bilangan bulat klasik.

Anda dapat mengirimkan program mandiri hibrid Q# terintegrasi atau Python + Q# program ke Azure Quantum. Untuk mengonfigurasi target profil untuk pekerjaan hibrid terintegrasi, ikuti instruksi di bawah ini.

Q# di Visual Studio Code

Untuk mengonfigurasi target profil untuk pekerjaan hibrid terintegrasi di Visual Studio Code, ikuti langkah-langkah berikut:

1. Q# Buka program di Visual Studio Code.
2. Pilih Tampilkan -> Palet Perintah dan ketik Q#: Atur profil QIR target Azure Quantum. Tekan Enter.
3. Pilih QIR Adaptive RI.

Setelah Anda mengatur QIR Adaptive RI sebagai target profil, Anda dapat mengirimkan program Anda Q# sebagai pekerjaan hibrid terintegrasi ke Quantinuum.

1. Pilih Tampilkan -> Palet Perintah dan ketik Q#: Sambungkan ke ruang kerja Azure Quantum. Tekan Enter.
2. Pilih akun Azure, dan ikuti perintah untuk menyambungkan ke direktori, langganan, dan ruang kerja pilihan Anda.
3. Setelah Anda tersambung, di panel Explorer , perluas Ruang Kerja Quantum.
4. Perluas ruang kerja Anda dan perluas penyedia Quantinuum .
5. Pilih Quantinuum apa pun yang tersedia target, misalnya quantinuum.sim.h1-1e.
6. Pilih ikon putar di sebelah kanan target nama untuk mulai mengirimkan program saat ini Q# .
7. Tambahkan nama untuk mengidentifikasi pekerjaan, dan jumlah bidikan.
8. Tekan Enter untuk mengirimkan pekerjaan. Status pekerjaan ditampilkan di bagian bawah layar.
9. Perluas Pekerjaan dan arahkan mouse ke atas pekerjaan Anda, yang menampilkan waktu dan status pekerjaan Anda.

Q# + Python

1. Saat menggunakan paket python qsharp , gunakan qsharp.init fungsi dan atur target_profile parameter ke Adaptive_RI.

   import qsharp
   
   qsharp.init(target_profile=qsharp.TargetProfile.Adaptive_RI)
   

2. Sambungkan ke ruang kerja Azure Quantum Anda.

   import azure.quantum
   
   workspace = azure.quantum.Workspace(
       resource_id = "", # add your resource ID
       location = "", # add your location, for example "westus"
   )
   

3. Atur target parameter ke Quantinuum target yang ingin Anda gunakan. Misalnya, untuk menggunakan quantinuum.sim.h1-1etarget:

   target = workspace.get_targets("quantinuum.sim.h1-1e")
   

Anda dapat menggabungkan beberapa pekerjaan hibrid terintegrasi dalam sesi menggunakan target.open_session fungsi . Untuk informasi selengkapnya, lihat Mulai menggunakan sesi.

Catatan

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

Fitur yang didukung

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

Fitur yang didukung	Catatan
Nilai Dynamics	Bool dan bilangan bulat yang nilainya bergantung pada hasil pengukuran
Perulangan	Perulangan yang terikat secara klasifikasi saja
Alur kontrol arbitrer	Penggunaan percabangan if/else
Pengukuran sirkuit tengah	Menggunakan sumber daya register klasik
Penggunaan kembali qubit	Didukung
Komputasi klasik real time	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 hibrid terintegrasi, Anda menerima pesan kesalahan pada waktu desain. Untuk informasi selengkapnya, lihat halaman wiki QIR.

Catatan

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

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

namespace HybridIntegrated {
    open Microsoft.Quantum.Measurement;
    open Microsoft.Quantum.Math;
    open Microsoft.Quantum.Convert;

    @EntryPoint()
    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 jenis 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 if ekspresi.

        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 hibrid terintegrasi

Anda dapat memperkirakan biaya menjalankan pekerjaan hibrid terintegrasi pada perangkat keras Quantinuum dengan menjalankannya di emulator terlebih dahulu.

Setelah berhasil dijalankan pada emulator:

1. Di ruang kerja Azure Quantum Anda, pilih Manajemen pekerjaan.
2. Pilih pekerjaan yang Anda kirimkan.
3. Dalam popup Detail pekerjaan, pilih Estimasi Biaya untuk melihat berapa banyak 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.

Catatan

Quantinuum membatalkan pendaftaran seluruh sirkuit dan menghitung biaya pada semua jalur kode, baik dijalankan secara kondisional atau tidak.

Sampel hibrid terintegrasi

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

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 sampel kode di sini.

Estimasi fase berulang

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

Sirkuit dimulai dengan mengodekan pasangan vektor pada target qubit dan ancilla qubit. Kemudian menerapkan operator Oracle ke seluruh register, dikontrol dari qubit kontrol, yang diatur dalam status $\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 sampel kode di sini.

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

Konten terkait

• Komputasi hibrid terdistribusi.
• Komputasi kuantum interaktif: sesi