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 QIR Adaptive RItarget profil. Profil RI target Adaptif menawarkan dukungan untuk pengukuran pertengahan sirkuit, 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, Anda memerlukan prasyarat berikut:
  • Visual Studio Code dengan ekstensi Azure Quantum Development Kit terinstal.
  • Versi terbaru ekstensi AzureQuantum 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

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

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

Mengirimkan pekerjaan RI adaptif

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

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

Untuk mengonfigurasi target profil untuk pekerjaan hibrid 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 menetapkan QIR Adaptive RI sebagai target profil, Anda dapat mengirimkan program Anda Q# sebagai pekerjaan kuantum hibrid 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 kuantum hibrid 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 kuantum hibrid 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 kuantum hibrid, Anda akan 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.

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

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 komputasi kuantum hibrid

Anda dapat memperkirakan biaya menjalankan pekerjaan komputasi kuantum hibrid 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 komputasi kuantum hibrid

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

Catatan

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

Konten terkait

• Mulai menggunakan sesi