Kirim pekerjaan ke Azure Quantum dengan QDKPython paket

Gunakan paket Microsoft Quantum Development Kit (QDK) Python untuk mengirim Q#, Qiskit, OpenQASM, Cirq, dan PennyLane program ke Azure Quantum.

Artikel ini menyediakan contoh pengiriman pekerjaan untuk setiap bahasa atau kerangka kerja kuantum yang didukung. Untuk alur kerja OpenQASM atau Q# interaktif yang tidak memerlukan kode Python, lihat Mengirim tugas dengan ekstensi QDK untuk VS Code.

Prasyarat

• Sebuah akun Azure dengan langganan aktif.

• Ruang Azure Quantum kerja. Untuk membuatnya, lihat Membuat Azure Quantum ruang kerja.

• Python 3.10 atau yang lebih baru.

• Jika Anda menggunakan notebook Jupyter, gunakan lingkungan Jupyter, seperti ekstensi Jupyter untuk VS Code dan paket ipykernel.

• Instal Azure CLI dengan quantum ekstensi.

  az extension add --upgrade --name quantum
  

• Instal paket versi terbaru qdkPython dengan ekstra azure dan jupyter.

  pip install --upgrade "qdk[azure,jupyter]"
  

  Jika Anda ingin mengirim program Qiskit atau Cirq, instal komponen tambahan cirq dan qiskit.

  pip install --upgrade "qdk[qiskit,cirq]"
  

Hubungkan ke Azure Quantum ruang kerja Anda

Sebelum mengirimkan pekerjaan, Anda perlu menyambungkan ke Azure Quantum ruang kerja. Modul qdk.azure menyediakan Workspace objek untuk terhubung ke Azure Quantum ruang kerja. Untuk menyambungkan ke ruang kerja Anda, ikuti langkah-langkah berikut.

Masuk dengan Azure CLI

Jika Anda belum melakukannya, masuk ke Azure dari terminal sebelum Anda membuka buku catatan Jupyter.

az login

Jika Anda tidak masuk dari terminal, Anda perlu mengautentikasi setiap kali Anda terhubung ke ruang kerja Quantum melalui Python. Jika akun Anda memiliki akses ke beberapa langganan, atur langganan yang berisi ruang kerja Anda Azure Quantum .

az account set --subscription <subscription-id>

Jalankan az login lagi saat sesi kedaluwarsa atau saat Anda ingin menggunakan akun Azure yang berbeda.

Mendapatkan ID sumber daya ruang kerja Anda

1. Masuk ke portal Azure.
2. Buka ruang kerja Quantum tempat Anda ingin mengirimkan pekerjaan Anda.
3. Di halaman Gambaran Umum , temukan dan salin ID Sumber Daya.

Sambungkan ke ruang kerja

1. Untuk terhubung ke ruang kerja Quantum Anda, buat objek Workspace dengan ID sumber daya yang Anda salin.

   from qdk.azure import Workspace
   
   workspace = Workspace(resource_id="") # Add your resource ID
   

   Nota

   Y

2. Periksa koneksi dan lihat targets yang tersedia di ruang kerja.

   for target in workspace.get_targets():
       print(target.name)
   

Untuk opsi koneksi dan autentikasi lainnya, lihat Menyambungkan ke ruang kerja AndaAzure Quantum.

Nota

Contoh berikut mengirimkan pekerjaan ke simulator targets. targets yang tersedia di ruang kerja Anda bergantung pada penyedia yang telah Anda konfigurasi.

Menyiapkan dan mengirimkan program Anda

Pilih tab untuk bahasa atau kerangka kerja kuantum Anda.

Q#

Gunakan modul qdk.qsharp untuk mendefinisikan atau memuat kode Q#, mengompilasi titik masuk ke QIR, dan mengirimkan QIR ke Azure Quantumtarget.

Menentukan dan mengkompilasi Q# program

1. Inisialisasi Q# dengan targetQIR profil yang didukung oleh Azure Quantumtarget.

   from qdk import qsharp, TargetProfile
   
   qsharp.init(target_profile=TargetProfile.Base)
   

   Untuk informasi selengkapnya tentang QIRtarget profil, lihat Azure QuantumQIRtarget profil di QDK.

2. Definisikan sebuah Q# operasi. Misalnya, gunakan operasi berikut RandomBit .

   qsharp.eval("""
       operation RandomBit() : Result {
           use q = Qubit();
           H(q);
           return MResetZ(q);
       }
   """)
   

3. Uji operasi pada simulator lokal.

   print(qsharp.run("RandomBit()", shots=10))
   

4. Kompilasikan operasi menjadi QIR.

   from qdk.qsharp import compile
   
   program = compile("RandomBit()")
   

Q# Mengirimkan pekerjaan

1. Pilih target yang kompatibel dari ruang kerja Anda.

   target = workspace.get_targets("rigetti.sim.qvm")
   

2. Kirim program yang dikompilasi.

   job = target.submit(program, "qsharp-job", shots=100)
   print("Job ID:", job.id)
   

3. Tunggu hingga pekerjaan selesai dan ambil hasilnya.

   job.wait_until_completed()
   print("Status:", job.details.status)
   
   results = job.get_results()
   print(results)
   

OpenQASM

qdk.openqasm Gunakan modul untuk mengkompilasi OpenQASM 3 kode sumber ke QIR, lalu kirimkan QIR ke Azure Quantumtarget.

Menentukan dan mengkompilasi OpenQASM program

1. Definisikan sirkuit OpenQASM sebagai string Python.

   qasm_source = """
   OPENQASM 3.0;
   include "stdgates.inc";
   
   bit[2] c;
   qubit[2] q;
   
   h q[0];
   cx q[0], q[1];
   c = measure q;
   """
   

2. Kompilasi program ke QIR.

   from qdk.openqasm import compile
   
   program = compile(qasm_source)
   

Kirim tugas OpenQASM

1. Pilih target yang menerima program yang dikompilasi.

   target = workspace.get_targets("ionq.simulator")
   

2. Kirim program yang dikompilasi.

   job = target.submit(program, "openqasm-job", shots=100)
   print("Job ID:", job.id)
   

3. Tunggu hingga pekerjaan selesai dan ambil hasilnya.

   job.wait_until_completed()
   print("Status:", job.details.status)
   
   results = job.get_results()
   print(results)
   

Untuk program berparameter OpenQASM , ikat nilai input sebelum Anda mengirimkan pekerjaan. Untuk informasi selengkapnya tentang OpenQASM di QDK, lihat Mengembangkan OpenQASM program di QDK.

Qiskit

Gunakan AzureQuantumProvider dari qdk.azure modul untuk mengirimkan Qiskit pekerjaan ke Azure Quantum penyedia. Objek penyedia mencantumkan Azure Quantumtargets yang kompatibel dan mengembalikan tugas serta hasil Qiskit.

Membuat Qiskit sirkuit

from qiskit import QuantumCircuit

circuit = QuantumCircuit(3, 3)
circuit.h(0)
circuit.cx(0, 1)
circuit.cx(1, 2)
circuit.measure([0, 1, 2], [0, 1, 2])

Kirim Qiskit tugas

1. Buat objek penyedia Azure Quantum dari ruang kerja.

   from qdk.azure.qiskit import AzureQuantumProvider
   
   provider = AzureQuantumProvider(workspace)
   

2. Cantumkan backend yang menerima Qiskit sirkuit.

   for backend in provider.backends():
       print(backend.name)
   

3. Pilih backend dan kirim sirkuit.

   backend = provider.get_backend("rigetti.sim.qvm")
   job = backend.run(circuit, shots=100)
   
   print("Job ID:", job.job_id())
   print("Status:", job.status())
   

4. Tunggu hingga pekerjaan selesai dan ambil hasilnya Qiskit .

   result = job.result()
   counts = result.get_counts(circuit)
   print(counts)
   

Adaptor Qiskit menangani Azure Quantum format input dan mengonversi respons penyedia ke hasil Qiskit .

Qiskit hasil tugas untuk program dengan hilangnya qubit

Beberapa perangkat keras kuantum dapat mengalami kehilangan qubit ketika program sedang berjalan. Jika kehilangan qubit terjadi di titik mana pun selama satu shot pada program Qiskit, maka shot tersebut akan dihapus dari hasil job Azure Quantum. Misalnya, jika kehilangan qubit terjadi dalam 10 dari 200 bidikan, maka hasil pekerjaan memiliki 190 jumlah pengukuran total.

Hasil mentah untuk semua bidikan, termasuk bidikan di mana kehilangan qubit terjadi, masih tersedia di results objek. Kode berikut menghasilkan kedua kumpulan hasil.

# Get results only for shots without qubit loss
print('Counts:', result.results[0].data.counts)
print('Probabilities:', result.results[0].data.probabilities)
print('Memory:', result.results[0].data.memory)

# Get the raw total shot results
print('Raw counts:', result.results[0].data.raw_counts)
print('Raw probabilities:', result.results[0].data.raw_probabilities)
print('Raw memory:', result.results[0].data.raw_memory)

Untuk pekerjaan atau targets yang tidak memiliki hilangnya qubit, hasil default dan hasil mentah identik.

Nota

Atribut memory untuk Qiskit hasil pekerjaan adalah daftar hasil pengukuran untuk setiap bidikan.

Cirq

Gunakan AzureQuantumService dari qdk.azure modul untuk mengirimkan Cirq pekerjaan ke Azure Quantum penyedia. Objek layanan mencantumkan Azure Quantumtargets yang kompatibel dan mengembalikan hasil native Cirq atau native penyedia.

Membuat Cirq sirkuit

import cirq

q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(
    cirq.H(q0),
    cirq.CX(q0, q1),
    cirq.measure(q0, q1, key="result"),
)

Kirimkan Cirq tugas

1. Azure Quantum Buat objek layanan.

   from qdk.azure.cirq import AzureQuantumService
   
   service = AzureQuantumService(workspace)
   

2. Cantumkan targets yang menerima sirkuit Cirq.

   for target in service.targets():
       print(target.name)
   

3. Buat pekerjaan asinkron.

   job = service.create_job(
       program=circuit,
       repetitions=100,
       target="ionq.simulator",
   )
   
   print("Status:", job.status())
   

4. Tunggu hingga pekerjaan selesai dan ambil hasilnya.

   result = job.results()
   print(result)
   

Format hasil tergantung pada penyedia dan target. Beberapa objek hasil penyedia dapat dikonversi ke cirq.Result objek.

PennyLane

Konversikan PennyLane node kuantum ke OpenQASM, kompilasi OpenQASM ke QIR, dan kirimkan QIR ke Azure Quantumtarget.

Membuat PennyLane sirkuit

Sirkuit berikut adalah sirkuit berparameter. Efek RY gerbang tergantung pada sudut theta.

import pennylane as qml

device = qml.device("default.qubit", wires=2)

@qml.qnode(device)
def circuit(theta):
    qml.Hadamard(wires=0)
    qml.CNOT(wires=[0, 1])
    qml.RY(theta, wires=1)
    return qml.expval(qml.PauliZ(1))

Mengonversi sirkuit menjadi QIR

1. Konversi sirkuit berparameter menjadi OpenQASM untuk nilai parameter tertentu.

   theta = 0.3
   qasm_source = qml.to_openqasm(circuit)(theta)
   

2. Kompilasikan OpenQASM ke QIR dengan profil target yang kompatibel.

   from qdk import TargetProfile
   from qdk.openqasm import compile
   
   program = compile(qasm_source, TargetProfile.Base)
   

Kirimkan tugas PennyLane

1. Pilih yang kompatibel target dan kirimkan QIR.

   target = workspace.get_targets("rigetti.sim.qvm")
   job = target.submit(program, "pennylane-job", shots=100)
   
   print("Job ID:", job.id)
   

2. Tunggu hingga pekerjaan selesai dan ambil hasilnya.

   job.wait_until_completed()
   print("Status:", job.details.status)
   
   results = job.get_results()
   print(results)
   

Format hasil tergantung pada penyedia dan target. Azure Quantum tidak mengembalikan PennyLane hasil node kuantum dari QIR yang dikirimkan.

Konten terkait

• Cara mengirimkan pekerjaan ke Azure Quantum
• Kirim tugas dengan ekstensi QDK untuk VS Code
• Kirim pekerjaan ke Azure Quantum dengan Azure CLI
• Bekerja pada Azure Quantum pekerjaan
• Dukungan bahasa pemrograman kuantum di QDK
• Azure Quantum penyedia komputasi targets