Azure Quantum QIR profil sasaran dalam QDK

Komputasi Quantum masih merupakan teknologi yang muncul. Tidak semua perangkat keras kuantum dapat menjalankan semua program kuantum. Misalnya, hanya perangkat keras tertentu yang dapat melakukan pengukuran pertengahan sirkuit, yang diperlukan untuk menjalankan program dengan cabang bersyarat berdasarkan hasil pengukuran kubit.

Ketika Anda mengirimkan program untuk dijalankan pada Azure Quantum, program Anda dikonversi ke format representasi perantara kuantum (QIR). QIR tidak bergantung pada bahasa pemrograman atau jenis perangkat keras kuantum yang dijalankan program Anda. Microsoft Quantum Development Kit (QDK) mendukung beberapa QIR profil target untuk kemampuan perangkat keras yang berbeda.

Untuk informasi selengkapnya tentang QIR, lihat Representasi perantara Quantum.

Gambaran umum profil target

Azure Quantum dan QDK mendukung beberapa profil target QIR. Jenis profil target yang Anda pilih menentukan konstruksi pemrograman mana yang dapat digunakan program Anda.

Percabangan kondisional dengan pernyataan if berdasarkan hasil pengukuran qubit
Operasi aritmatika pada angka titik mengambang yang dihitung dari hasil pengukuran kubit
Loop tetap dan tak terbatas berdasarkan hasil pengukuran qubit

Tabel berikut mencantumkan semua QIR profil target di QDK serta konstruksi pemrograman yang didukung oleh profil target tersebut, diurutkan dari yang paling ketat hingga yang paling tidak ketat.

QIR profil sasaran	Cabang kondisional	Operasi titik mengambang	Loops
Base	❌	❌	❌
Adaptive RI	✅	❌	❌
Adaptive RIF	✅	✅	❌
Adaptive	✅	✅	✅
Unrestricted	✅	✅	✅

Atur profil target di QDK

Untuk menjalankan program pada simulator QDK atau target Azure Quantum, Anda perlu menetapkan profil target QIR. Jika Anda tidak mengatur profil target secara manual, QDK coba atur profil yang sesuai secara otomatis untuk target yang dipilih.

saat mengirimkan program untuk dijalankan melalui Azure Quantum layanan, QDK mencoba untuk secara otomatis memilih profil yang sesuai untuk target eksekusi yang dipilih.

Base QIR profil

Profil target dasar QIR adalah yang paling ketat. Gunakan profil dasar untuk program yang lebih sederhana yang tidak menggunakan struktur pemrograman klasik seperti cabang dan perulangan. Jika target perangkat keras kuantum Anda tidak dapat melakukan pengukuran pertengahan sirkuit, maka Anda mungkin perlu menggunakan profil dasar.

Target berikut Azure Quantum dapat menjalankan program yang menggunakan profil dasar QIR .

Provider	Simulator	Unit Pengolahan Kuantum (QPU)
IonQ	`ionq.simulator`	`ionq.qpu.*`
Rigetti	`rigetti.sim.*`	`rigetti.qpu.*`

Untuk mempelajari selengkapnya tentang penyedia ini Azure Quantum , lihat penyedia IonQ dan penyedia Rigetti.

Mengatur profil dasar

Untuk mengatur profil target dasar QIR di QDK ekstensi untuk Visual Studio Code (Visual Studio Code), pilih salah satu opsi berikut.

Jika Anda menyiapkan proyek Q#, tambahkan perintah berikut ke file proyek qsharp.json Anda.
```
{
  "targetProfile": "base"
}
```
Jika Anda bekerja dalam .qs file yang bukan bagian dari proyek Q#, atur profil target langsung dalam kode Q#Anda. Untuk melakukannya, tambahkan @EntryPoint(Base) pada baris sebelum operasi entry point di program Anda.
```
@EntryPoint(Base)
operation Main() : Unit {

...

}
```

Untuk mengatur profil target dasar dalam QDK paket Python, jalankan kode berikut.

from qdk import init, TargetProfile

init(target_profile=TargetProfile.Base)

Batasan pada program Q# dengan profil dasar

Profil target dasar dapat menjalankan berbagai program Q#. Batasan utamanya adalah bahwa program Q# tidak dapat melakukan perbandingan logis dengan Result nilai jenis dari operasi pengukuran.

Misalnya, Anda tidak dapat menjalankan operasi berikut FlipQubitOnZero pada target dasar karena program berisi if pernyataan yang menggunakan hasil pengukuran.

    @EntryPoint(Base)
    operation FlipQubitOnZero() : Unit {
        use q = Qubit();
        if M(q) == Zero {
            X(q);
        }
    }

Adaptive RI QIR profil

Profil target RI adaptif dapat menjalankan berbagai program yang lebih luas daripada profil dasar, tetapi masih memiliki beberapa batasan. Adaptive RI menargetkan program dukungan yang menggunakan pengukuran pertengahan sirkuit dalam pernyataan kondisi if . Jika perangkat keras kuantum Anda dapat melakukan pengukuran pertengahan sirkuit dan program Anda menggunakan if pernyataan berdasarkan hasil pengukuran, maka Anda mungkin perlu menggunakan profil RI adaptif.

Misalnya, program Q# berikut dapat berjalan pada target RI adaptif.

@EntryPoint(Adaptive_RI)
operation MeasureQubit(q : Qubit) : Result { 
    return M(q); 
}

operation SetToZero(q : Qubit) : Unit {
     if MeasureQubit(q) == One { X(q); }
}

Target berikut Azure Quantum dapat menjalankan program yang menggunakan profil target RI adaptif.

Provider	Simulator	Unit Pengolahan Kuantum (QPU)
Quantinuum	`quantinuum.sim.h2-1e`	`quantinuum.qpu.h2-1`
Quantinuum	`quantinuum.sim.h2-2e`	`quantinuum.qpu.h2-2`

Untuk informasi selengkapnya tentang Quantinuum di Azure Quantum, lihat Penyedia Quantinuum.

Mengatur profil RI adaptif

Untuk mengatur profil target RI QIR adaptif dalam QDK ekstensi untuk Visual Studio Code, pilih salah satu opsi berikut.

Jika Anda menyiapkan proyek Q#, tambahkan perintah berikut ke file proyek qsharp.json Anda:
```
{
  "targetProfile": "adaptive_ri"
}
```
Jika Anda bekerja dalam .qs file yang bukan bagian dari proyek Q#, atur profil target langsung dalam kode Q#Anda. Untuk melakukannya, tambahkan @EntryPoint(Adaptive_RI) pada baris sebelum operasi entry point di program Anda.
```
@EntryPoint(Adaptive_RI)
operation Main() : Unit {

...

}
```

Untuk mengatur profil target RI adaptif dalam QDK paket Python, jalankan kode berikut.

from qdk import init, TargetProfile

init(target_profile=TargetProfile.Adaptive_RI)

Adaptive RIF QIR profil

Profil target RIF adaptif memiliki kemampuan yang sama dengan profil RI adaptif, tetapi juga mendukung program yang berisi operasi aritmatika floating point. Jika perangkat keras kuantum Anda dapat melakukan pengukuran pertengahan sirkuit, dan program Anda menggunakan if pernyataan dan angka titik mengambang yang dihitung dari hasil pengukuran, maka Anda mungkin perlu menggunakan profil RIF adaptif.

Misalnya, program Q# berikut dapat berjalan pada target RIF adaptif.

@EntryPoint(Adaptive_RIF)
operation DynamicFloat() : Double {
    use q = Qubit();
    H(q);
    mutable f = 0.0;
    if M(q) == One {
        f = 0.5;
    }
    Reset(q);
    return f;
}

Azure Quantum tidak memiliki target RIF adaptif saat ini, tetapi Anda dapat menjalankan program untuk target RIF adaptif pada simulator lokal QDK . Untuk informasi selengkapnya tentang simulator di QDK, lihat Gambaran umum simulator kuantum di QDK.

Mengatur profil RIF adaptif

Untuk mengatur profil target RIF QIR adaptif di QDK ekstensi untuk Visual Studio Code, pilih salah satu opsi berikut.

Jika Anda menyiapkan proyek Q#, tambahkan perintah berikut ke file proyek qsharp.json Anda:
```
{
  "targetProfile": "adaptive_rif"
}
```
Jika Anda bekerja dalam .qs file yang bukan bagian dari proyek Q#, atur profil target langsung dalam kode Q#Anda. Untuk melakukannya, tambahkan @EntryPoint(Adaptive_RIF) pada baris sebelum operasi entry point di program Anda.
```
@EntryPoint(Adaptive_RIF)
operation Main() : Unit {

...

}
```

Untuk mengatur profil target RIF adaptif dalam QDK paket Python, jalankan kode berikut.

from qdk import init, TargetProfile

init(target_profile=TargetProfile.Adaptive_RIF)

Adaptive QIR profil

Profil target adaptif memiliki kemampuan yang sama dengan profil RIF adaptif, tetapi juga mendukung program yang menggunakan perulangan berdasarkan hasil pengukuran. Adaptive program-program dapat menggunakan perulangan dengan jumlah iterasi tertentu, dan perulangan ulangi-sampai-berhasil (RUS).

Azure Quantum tidak memiliki target adaptif saat ini, tetapi Anda dapat menjalankan program untuk target adaptif pada simulator lokal QDK . Untuk informasi selengkapnya tentang simulator di QDK, lihat Gambaran umum simulator kuantum di QDK.

Mengatur profil adaptif

Untuk mengatur profil target adaptif QIR dalam QDK ekstensi untuk Visual Studio Code, pilih salah satu opsi berikut.

Jika Anda menyiapkan proyek Q#, tambahkan perintah berikut ke file proyek qsharp.json Anda:
```
{
  "targetProfile": "adaptive"
}
```
Jika Anda bekerja dalam .qs file yang bukan bagian dari proyek Q#, atur profil target langsung dalam kode Q#Anda. Untuk melakukannya, tambahkan @EntryPoint(Adaptive) pada baris sebelum operasi entry point di program Anda.
```
@EntryPoint(Adaptive)
operation Main() : Unit {

...

}
```

Untuk mengatur profil target adaptif dalam QDK paket Python, jalankan kode berikut.

from qdk import init, TargetProfile

init(target_profile=TargetProfile.Adaptive)

Unrestricted QIR profil

Profil target yang tidak dibatasi dapat menjalankan semua program kuantum. Tidak ada target kuantum saat ini yang mendukung unrestricted QIR, tetapi Anda dapat menggunakan profil yang tidak dibatasi untuk menjalankan program kompleks pada QDK simulator untuk pengembangan kuantum.

Mengatur profil yang tidak dibatasi

Untuk mengatur profil target yang tidak dibatasi QIR dalam QDK ekstensi untuk Visual Studio Code, pilih salah satu opsi berikut.

Jika Anda menyiapkan proyek Q#, tambahkan perintah berikut ke file proyek qsharp.json Anda:
```
{
  "targetProfile": "unrestricted"
}
```
Jika Anda bekerja dalam .qs file yang bukan bagian dari proyek Q#, atur profil target langsung dalam kode Q#Anda. Untuk melakukannya, tambahkan @EntryPoint(Unrestricted) pada baris sebelum operasi entry point di program Anda.
```
@EntryPoint(Unrestricted)
operation Main() : Unit {

...

}
```

Untuk mengatur profil target yang tidak dibatasi dalam QDK paket Python, jalankan kode berikut.

from qdk import init, TargetProfile

init(target_profile=TargetProfile.Unrestricted)

Saran dan Komentar

Apakah halaman ini membantu?

Last updated on 2026-07-31