Tutorial: Mengirimkan program QIR ke Azure Quantum Resource Estimator

Azure Quantum Resource Estimator dibangun di atasQuantum Intermediate Representation (QIR), spesifikasi yang sepenuhnya dapat dioperasikan untuk program kuantum. QIR berfungsi sebagai antarmuka umum antara bahasa pemrograman kuantum dan kerangka kerja, dan targetplatform komputasi kuantum ed. Karena Estimator Sumber Daya mengambil program QIR sebagai input, ia mendukung bahasa apa pun yang diterjemahkan ke QIR. Misalnya, dapat digunakan oleh SDK kuantum dan bahasa populer seperti Q# dan Qiskit. Dalam tutorial ini, Anda akan menulis dan mengirimkan program QIR ke Estimator Sumber Daya. Tutorial ini menggunakan PyQIR untuk menghasilkan QIR, namun, Anda dapat menggunakan sumber QIR lainnya.

Dalam tutorial ini, Anda akan mempelajari cara:

• Sambungkan ke layanan Azure Quantum.
• Menentukan fungsi untuk membuat pekerjaan estimasi sumber daya dari bitcode QIR
• Membuat bitcode QIR menggunakan generator PyQIR
• Mengirimkan pekerjaan QIR ke Estimator Sumber Daya

Daftar langganan uji coba Azure gratis selama 30 hari.

Prasyarat

• Akun Azure dengan langganan aktif. Jika Anda tidak memiliki akun Azure, daftar secara gratis dan daftar untuk langganan prabayar.
• Ruang kerja Azure Quantum. Untuk informasi selengkapnya, lihat Buat ruang kerja Azure Quantum.
• Penyedia Komputasi Microsoft Quantum ditambahkan ke ruang kerja Anda.

Membuat buku catatan baru di ruang kerja Anda

1. Masuk ke portal Microsoft Azure dan pilih ruang kerja Azure Quantum Anda.
2. Di bawah Operasi, pilih Buku Catatan
3. Klik Buku catatan saya dan klik Tambahkan Baru
4. Di Jenis Kernel, pilih IPython.
5. Ketik nama untuk file tersebut, dan klik Buat file.

Saat buku catatan baru Anda terbuka, buku catatan secara otomatis membuat kode untuk sel pertama, berdasarkan informasi langganan dan ruang kerja Anda.

from azure.quantum import Workspace
workspace = Workspace ( 
    resource_id = "", # Your resource_id 
    location = ""  # Your workspace location (for example, "westus") 
)

Catatan

Kecuali dinyatakan lain, Anda harus menjalankan setiap sel agar Anda membuatnya untuk menghindari masalah kompilasi.

Klik ikon segitiga "putar" di sebelah kiri sel untuk menjalankan kode.

Memuat impor yang diperlukan

Pertama, Anda perlu mengimpor beberapa kelas dan fungsi Python dari azure.quantum, , qiskitdan pyqir. Anda tidak akan menggunakan Qiskit untuk membangun sirkuit kuantum secara langsung, tetapi Anda akan menggunakan AzureQuantumJob, yang dibangun di atas ekosistem Qiskit. Pastikan Anda menggunakan Qiskit versi terbaru. Untuk informasi selengkapnya, lihat Memperbarui paket Python azure-quantum.

from azure.quantum.qiskit import AzureQuantumProvider
from azure.quantum.qiskit.job import AzureQuantumJob
from pyqir.generator import BasicQisBuilder, SimpleModule

Menyambungkan ke layanan Azure Quantum

Selanjutnya, buat AzureQuantumProvider objek menggunakan workspace objek dari sel sebelumnya untuk menyambungkan ke ruang kerja Azure Quantum Anda.

provider = AzureQuantumProvider(workspace)

Menentukan fungsi untuk membuat pekerjaan estimasi sumber daya dari QIR

Estimator Sumber Daya adalah target penyedia Komputasi Microsoft Quantum. Menggunakan Estimator Sumber Daya sama persis dengan mengirimkan pekerjaan terhadap penyedia targets perangkat lunak dan perangkat keras lain di Azure Quantum - tentukan program Anda, atur target, dan kirimkan pekerjaan Anda untuk komputasi.

Saat mengirimkan permintaan perkiraan sumber daya untuk program Anda, Anda dapat menentukan beberapa target parameter.

• errorBudget - anggaran kesalahan yang diizinkan secara keseluruhan
• qecScheme - skema koreksi kesalahan kuantum (QEC)
• qubitParams - parameter qubit fisik
• constraints - batasan pada tingkat komponen

Untuk informasi selengkapnya tentang parameter input, lihat Parameter target Estimator Sumber Daya.

Untuk contoh ini, Anda akan menerapkan fungsi generik yang mengambil sebagai input provider objek yang terhubung ke ruang kerja Azure Quantum Anda dan bitcode QIR dari program kuantum. Ini mengembalikan sebagai hasil dari pekerjaan Azure Quantum. Parameter Estimator target Sumber Daya dapat diteruskan melalui argumen kata kunci ke fungsi .

def resource_estimation_job_from_qir(provider: AzureQuantumProvider, bitcode: bytes, **kwargs):
    """A generic function to create a resource estimation job from QIR bitcode"""

    # Find the Resource Estimator target from the provider
    backend = provider.get_backend('microsoft.estimator')

    # You can provide a name for the job via keyword arguments; if not,
    # use QIR job as a default name
    name = kwargs.pop("name", "QIR job")

    # Wxtract some job specific arguments from the backend's configuration
    config = backend.configuration()
    blob_name = config.azure["blob_name"]
    content_type = config.azure["content_type"]
    provider_id = config.azure["provider_id"]
    output_data_format = config.azure["output_data_format"]

    # Finally, create the Azure Quantum jon object and return it
    return AzureQuantumJob(
        backend=backend,
        target=backend.name(),
        name=name,
        input_data=bitcode,
        blob_name=blob_name,
        content_type=content_type,
        provider_id=provider_id,
        input_data_format="qir.v1",
        output_data_format=output_data_format,
        input_params = kwargs,
        metadata={}
    )

Menjalankan program kuantum sampel

Selanjutnya, buat beberapa bitcode QIR menggunakan generator PyQIR. Contoh ini membangun gerbang S terkontrol menggunakan tiga gerbang T dan dua gerbang CNOT.

module = SimpleModule("Controlled S", num_qubits=2, num_results=0)
qis = BasicQisBuilder(module.builder)

[a, b] = module.qubits[0:2]
qis.t(a)
qis.t(b)
qis.cx(a, b)
qis.t_adj(b)
qis.cx(a, b)

Anda dapat menggunakan fungsi yang Anda tentukan di atas bersama dengan bitcode() fungsi dari PyQIR untuk menghasilkan pekerjaan estimasi sumber daya. Anda juga dapat meneruskan argumen spesifik Estimator Sumber Daya. Contoh ini menggunakan errorBudget untuk mengatur tingkat kesalahan ke 5%. Untuk informasi selengkapnya tentang target parameter, lihat Parameter target Estimator Sumber Daya.

job = resource_estimation_job_from_qir(provider, module.bitcode(), errorBudget=0.05)
result = job.result()
result

Fungsi ini membuat tabel yang menunjukkan jumlah sumber daya fisik secara keseluruhan. Anda dapat memeriksa detail biaya lebih lanjut dengan menciutkan grup yang memiliki informasi lebih lanjut. Misalnya, jika Anda menciutkan grup parameter Kubit logis , Anda dapat lebih mudah melihat bahwa jarak kode koreksi kesalahan adalah 15.

Parameter kubit logis	Nilai
Skema QEC	surface_code
Jarak kode	5
Kubit fisik	50
Waktu siklus logis	2us
Tingkat kesalahan kubit logis	3.00E-5
Prefaktor persimpangan	0,03
Ambang koreksi kesalahan	0.01
Rumus waktu siklus logis	(4 * twoQubitGateTime + 2 * oneQubitMeasurementTime) * codeDistance
Rumus qubit fisik	2 * codeDistance * codeDistance

Dalam grup Parameter kubit fisik, Anda dapat melihat properti kubit fisik yang diasumsikan untuk estimasi ini. Misalnya, waktu untuk melakukan pengukuran kubit tunggal dan gerbang qubit tunggal masing-masing diasumsikan 100 ns dan 50 ns.

Parameter kubit fisik	Nilai
Nama qubit	qubit_gate_ns_e3
Set instruksi	GateBased
Waktu pengukuran kubit tunggal	100 ns
Waktu gerbang T	50 ns
Tingkat kesalahan gerbang T	0.001
Tingkat kesalahan pengukuran kubit tunggal	0.001
Waktu gerbang qubit tunggal	50 ns
Tingkat kesalahan qubit tunggal	0.001
Waktu gerbang dua qubit	50 ns
Tingkat kesalahan dua-qubit	0.001

Untuk informasi selengkapnya, lihat daftar lengkap data output untuk Estimator Sumber Daya.

Konten terkait

Terus jelajahi algoritma dan teknik kuantum lainnya:

• Tutorial Menerapkan algoritma pencarian Grover menunjukkan cara menulis program Q# yang menggunakan algoritma pencarian Grover untuk memecahkan masalah pewarnaan grafik.
• Tutorial Jelajahi entanglemen kuantum dengan Q# menunjukkan cara mengoperasikan qubit dengan Q# untuk mengubah keadaan mereka, dan menunjukkan efek superposisi dan entanglemen.
• Quantum Katas adalah tutorial berbasis Jupyter Notebook, mandiri, dan latihan pemrograman yang bertujuan untuk mengajarkan elemen komputasi kuantum dan pemrograman Q# secara bersamaan.