Cara mengirimkan sirkuit dengan Cirq ke Azure Quantum

Pelajari cara mengirimkan sirkuit kuantum Cirq menggunakan azure-quantumPython paket . Anda dapat mengirimkan sirkuit Cirq ke Azure Quantum menggunakan notebook Azure Quantum, yang memiliki paket bawaan azure-quantumPython , atau dari komputer lokal Anda.

Untuk informasi selengkapnya, lihat Sirkuit kuantum.

Catatan

Microsoft Quantum Development Kit (Classic QDK) tidak akan lagi didukung setelah 30 Juni 2024. Jika Anda adalah pengembang QDK yang sudah ada, kami sarankan Anda beralih ke Azure Quantum Development Kit (Modern QDK) baru untuk terus mengembangkan solusi kuantum. Untuk informasi selengkapnya, lihat Memigrasikan kode Q# Anda ke QDK Modern.

Prasyarat

Untuk detail penginstalan, lihat Menginstal QDK Modern di Visual Studio Code.

• Ruang kerja Azure Quantum di langganan Azure Anda. Untuk membuat ruang kerja, lihat Membuat ruang kerja Azure Quantum.

• Lingkungan Python dengan Python dan Pip terinstal.

• Visual Studio Code dengan Azure Quantum Development Kit, Python, dan ekstensi Jupyter terinstal.

• Paket Azure Quantum azure-quantum dengan tag [cirq], dan qsharp dan ipykernel paket.

  python -m pip install --upgrade azure-quantum[cirq] qsharp ipykernel 
  

  Catatan

  Jika kernel ipykernel Jupyter Python tidak terdeteksi, Visual Studio Code akan meminta Anda untuk menginstalnya.

Membuat Jupyter Notebook

1. Di Visual Studio Code, pilih Tampilkan > palet Perintah dan pilih Buat: Jupyter Notebook Baru.
2. Di kanan atas, Visual Studio Code akan mendeteksi dan menampilkan versi Python dan lingkungan virtual Python yang dipilih untuk buku catatan. Jika Anda memiliki beberapa Python lingkungan, Anda mungkin perlu memilih kernel menggunakan pemilih kernel di kanan atas. Jika tidak ada lingkungan yang terdeteksi, lihat Jupyter Notebooks di VISUAL Studio Code untuk informasi penyiapan.

Memuat impor yang diperlukan

Di sel pertama buku catatan Anda, jalankan kode berikut untuk memuat impor yang diperlukan:

import azure.quantum
from azure.quantum.cirq import AzureQuantumService

Menyambungkan ke layanan Azure Quantum

Untuk dapat tersambung ke layanan Azure Quantum, program Anda memerlukan ID sumber daya dan lokasi ruang kerja Azure Quantum Anda. Masuk ke akun Azure Anda, https://portal.azure.com, navigasikan ke ruang kerja Azure Quantum Anda, dan salin nilai dari header.

Tambahkan sel baru dan gunakan informasi akun Anda untuk membuat Workspace objek dan AzureQuantumService untuk menyambungkan ke ruang kerja Azure Quantum Anda.

workspace = Workspace(  
    resource_id = "", # Add the resourceID of your workspace
    location = "" # Add the location of your workspace (for example "westus")
    )

service = AzureQuantumService(workspace)

Cantumkan semua targets

targets()Gunakan metode untuk mencantumkan targets semua di ruang kerja Anda yang dapat menjalankan sirkuit Anda, termasuk waktu dan ketersediaan antrean saat ini.

Catatan

targets Semua di ruang kerja Anda mungkin tidak tercantum - hanya targets yang dapat menerima sirkuit Cirq atau OpenQASM yang akan tercantum di sini.

print(service.targets())

[<Target name="quantinuum.qpu.h1-1", avg. queue time=0 s, Degraded>,
<Target name="quantinuum.sim.h1-1sc", avg. queue time=1 s, Available>,
<Target name="quantinuum.sim.h1-1e", avg. queue time=40 s, Available>,
<Target name="ionq.qpu", avg. queue time=229 s, Available>,
<Target name="ionq.simulator", avg. queue time=3 s, Available>,
<Target name="ionq.qpu.aria-1", avg. queue time=1136774 s, Available>]

Membuat sirkuit sederhana

Selanjutnya, buat sirkuit Cirq sederhana untuk dijalankan. Sirkuit ini menggunakan akar kuadrat dari gerbang X, asli dari sistem perangkat keras IonQ.

import cirq

q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(
    cirq.X(q0)**0.5,             # Square root of X
    cirq.CX(q0, q1),              # CNOT
    cirq.measure(q0, q1, key='b') # Measure both qubits
)
print(circuit)

0: ───X^0.5───@───M────────
              │   │
1: ───────────X───M────────

Pilih untuk target menjalankan program Anda

IonQ

Jalankan pada simulator IonQ

Anda sekarang dapat menjalankan program melalui layanan Azure Quantum dan mendapatkan hasilnya. Sel berikut mengirimkan pekerjaan (ke simulator IonQ default) yang menjalankan sirkuit dengan 100 bidikan, menunggu sampai pekerjaan selesai, dan mengembalikan hasilnya.

result = service.run(program=circuit, repetitions=100, target="ionq.simulator")

Langkah ini akan memunculkan objek cirq.Result.

print(result)

    b=1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010, 1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010

Memperkirakan biaya pekerjaan

Sebelum menjalankan pekerjaan di QPU, Anda dapat memperkirakan berapa biaya untuk menjalankannya. Untuk memperkirakan biaya menjalankan pekerjaan di QPU, Anda dapat menggunakan metode estimate_cost ini:

cost = service.estimate_cost(
    program=circuit,
    repetitions=100,
    target="ionq.qpu"
)

print(f"Estimated cost: {cost.estimated_total}")

Langkah ini akan mencetak perkiraan biaya dalam USD.

Untuk detail harga terbaru, lihat Harga IonQ, atau temukan ruang kerja Anda dan lihat opsi harga di tab "Penyedia" ruang kerja melalui: aka.ms/aq/myworkspaces.

Menjalankan di IonQ QPU

Pekerjaan sebelumnya berjalan di simulator default, "ionq.simulator". Namun, Anda juga dapat menjalankannya pada prosesor perangkat keras IonQ (Quantum Processor Unit (QPU)). Untuk berjalan di QPU IonQ, berikan "ionq.qpu" sebagai target argumen:

result = service.run(
    program=circuit,
    repetitions=100,
    target="ionq.qpu",
    timeout_seconds=500 # Set timeout to accommodate queue time on QPU
)

Sekali lagi, cara ini akan menampilkan objek cirq.Result.

print(result)

b=0101011011011111100001011101101011011110100010000000011110111000100100110110101100110001001111101111, 0101011011011111100001011101101011011110100010000000011110111000100100110110101100110001001111101111

Model asinkron menggunakan Jobs

Untuk sirkuit yang berjalan lama, dapat berguna untuk menjalankannya secara asinkron. Metode ini service.create_job mengembalikan objek Job, yang dapat Anda gunakan untuk mendapatkan hasil setelah pekerjaan berjalan dengan sukses.

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

Untuk memeriksa status pekerjaan, gunakan job.status():

print(job.status())

'completed'

Untuk menunggu pekerjaan selesai dan kemudian mendapatkan hasilnya, gunakan panggilan pemblokiran job.results():

result = job.results()
print(result)

00: 0.5
11: 0.5

Perhatikan bahwa cara ini tidak akan menampilkan objek cirq.Result. Sebaliknya, fungsi tersebut akan menampilkan objek hasil yang khusus untuk simulator IonQ dan menggunakan probabilitas status, daripada data bidikan.

type(result)

cirq_ionq.results.SimulatorResult

Untuk mengubah ini menjadi objek cirq.Result, gunakan result.to_cirq_result():

print(result.to_cirq_result())

b=1110101111111110111000011101011111001100010000001011011101001111001111001101100111010000001100011100, 1110101111111110111000011101011111001100010000001011011101001111001111001101100111010000001100011100

Quantinuum

Jalankan pada simulator Quantinuum

Anda sekarang dapat menjalankan program melalui layanan Azure Quantum dan mendapatkan hasilnya. Sel berikut mengirimkan pekerjaan yang menjalankan sirkuit dengan 100 bidikan, menunggu sampai pekerjaan selesai, dan menampilkan hasilnya.

result = service.run(program=circuit, repetitions=100, target="quantinuum.sim.h1-1sc")

Langkah ini akan memunculkan objek cirq.Result.

print(result)

    b=0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Anda dapat merencanakan hasilnya dalam histogram:

import pylab as pl

pl.hist(result.data)
pl.ylabel("Counts")
pl.xlabel("Result")

Saat melihat histogram, Anda mungkin memperhatikan bahwa generator angka acak kembali ke 0 sehingga tidak terlalu acak. Ini dikarenakan, saat API Validator memastikan bahwa kode Anda akan berjalan dengan sukses di perangkat keras Quantinuum, API juga akan kembali ke 0 untuk setiap pengukuran kuantum. Untuk generator angka acak nyata, Anda harus menjalankan sirkuit di perangkat keras kuantum.

Memperkirakan biaya pekerjaan

Sebelum menjalankan pekerjaan di QPU, Anda dapat memperkirakan berapa biaya untuk menjalankannya. Untuk memperkirakan biaya pelaksanaan pekerjaan di QPU, Anda dapat menggunakan metode ini estimate_cost.

Catatan

Untuk menjalankan perkiraan biaya terhadap Quantinuum target, Anda harus terlebih dahulu memuat ulang paket azure-quantumPython dengan parameter [qiskit] , dan memastikan bahwa Anda memiliki versi Qiskit terbaru. Untuk informasi selengkapnya, lihat Memperbarui paket azure-quantumPython.

cost = service.estimate_cost(
    program=circuit,
    repetitions=100,
    target="quantinuum.qpu.h1-1"
)

print(f"Estimated cost: {cost.estimated_total}")

Ini mencetak perkiraan biaya dalam Kredit Sistem H (HQC).

Untuk detail harga terbaru, lihat Harga Azure Quantum, atau temukan ruang kerja Anda dan lihat opsi harga di tab "Penyedia" ruang kerja Anda melalui: aka.ms/aq/myworkspaces.

Alur kerja asinkron menggunakan Jobs

Untuk sirkuit yang berjalan lama, dapat berguna untuk menjalankannya secara asinkron. Metode ini service.create_job mengembalikan objek Job, yang dapat Anda gunakan untuk mendapatkan hasil setelah pekerjaan berjalan dengan sukses.

job = service.create_job(
    program=circuit,
    repetitions=100,
    target="quantinuum.sim.h1-1sc"
)

Untuk memeriksa status pekerjaan, gunakan job.status():

print(job.status())

'Waiting'

Untuk menunggu pekerjaan selesai dan kemudian mendapatkan hasilnya, gunakan panggilan pemblokiran job.results():

result = job.results()
print(result)

    {'m_b': ['00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00']}

Perhatikan bahwa cara ini tidak akan menampilkan objek cirq.Result. Sebaliknya, ia mengembalikan kamus hasil pengukuran string bit yang diindeks oleh kunci pengukuran.

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.

Membuat buku catatan baru di ruang kerja Anda

1. Masuk ke portal Microsoft Azure lalu pilih ruang kerja dari langkah sebelumnya.
2. Di sisi kiri, pilih Notebooks.
3. Klik Notebooks Saya lalu klik Tambahkan Baru.
4. Ketik nama untuk file, misalnya Cirq.ipynb, lalu klik Buat file.

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

from azure.quantum import Workspace
workspace = Workspace ( 
  resource_id = "", # Add your resource_id 
  location = ""  # Add 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 harus mengimpor modul tambahan.

Klik + Kode untuk menambahkan sel baru, lalu tambahkan dan jalankan kode berikut:

from azure.quantum.cirq import AzureQuantumService

Menyambungkan ke layanan Azure Quantum

Selanjutnya, buat AzureQuantumService objek menggunakan workspace objek dari sel sebelumnya untuk menyambungkan ke ruang kerja Azure Quantum Anda. Tambahkan sel baru dengan kode berikut:

provider = AzureQuantumService(workspace)

Menentukan sirkuit sederhana

Selanjutnya, buat sirkuit Cirq sederhana untuk dijalankan. Sirkuit ini menggunakan akar kuadrat dari gerbang X, asli dari sistem perangkat keras IonQ.

import cirq

q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(
    cirq.X(q0)**0.5,             # Square root of X
    cirq.CX(q0, q1),              # CNOT
    cirq.measure(q0, q1, key='b') # Measure both qubits
)
print(circuit)

0: ───X^0.5───@───M────────
              │   │
1: ───────────X───M────────

Cantumkan semua targets

targets()Gunakan metode untuk mencantumkan targets semua di ruang kerja Anda yang dapat menjalankan sirkuit Anda, termasuk waktu dan ketersediaan antrean saat ini.

Catatan

targets Semua di ruang kerja Anda mungkin tidak tercantum - hanya targets yang dapat menerima sirkuit Cirq atau OpenQASM yang akan dicantumkan di sini.

print("This workspace's targets:")
for target in service.targets():
     print(target)

This workspace's targets:
<Target name="quantinuum.qpu.h1-1", avg. queue time=0 s, Degraded>
<Target name="quantinuum.sim.h1-1sc", avg. queue time=1 s, Available>
<Target name="quantinuum.sim.h1-1e", avg. queue time=40 s, Available>
<Target name="ionq.qpu", avg. queue time=229 s, Available>
<Target name="ionq.simulator", avg. queue time=3 s, Available>
<Target name="ionq.qpu.aria-1", avg. queue time=1136774 s, Available>

Catatan

Daftar target lengkap mungkin berbeda untuk ruang kerja Anda.

target Pilih untuk menjalankan program Anda

IonQ

Jalankan di simulator IonQ

Untuk memeriksa sirkuit Anda sebelum menjalankannya di perangkat keras kuantum yang sebenarnya, Anda dapat menggunakan simulator IonQ, ionq.simulator.

Sel berikut mengirimkan pekerjaan yang menjalankan sirkuit dengan 100 bidikan, menunggu sampai pekerjaan selesai, dan menampilkan hasilnya.

result = service.run(
    program=circuit,
    repetitions=100,
    target="ionq.simulator"
)

Langkah ini akan memunculkan objek cirq.Result.

print(result)

    b=1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010, 1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010

Anda dapat merencanakan hasilnya dalam histogram:

import pylab as pl

pl.hist(result.data)
pl.ylabel("Counts")
pl.xlabel("Result")

Memperkirakan biaya pekerjaan

Sebelum menjalankan pekerjaan di perangkat keras kuantum yang sebenarnya, atau unit pemrosesan kuantum (QPU), Anda dapat memperkirakan biaya pelaksanaan. Untuk memperkirakan biaya menjalankan pekerjaan di QPU, Anda dapat menggunakan metode ini estimate_cost:

cost = service.estimate_cost(
    program=circuit,
    repetitions=100,
    target="ionq.qpu"
)

print(f"Estimated cost: {cost.estimated_total}")

Estimated cost: 1

Langkah ini akan mencetak perkiraan biaya dalam USD.

Untuk detail harga terbaru, lihat Harga IonQ, atau lihat opsi harga di bilah Penyedia ruang kerja Anda. Untuk melihat status dan penggunaan kredit Anda saat ini, pilih Kredit dan kuota.

Menjalankan di IonQ QPU

Pekerjaan sebelumnya berjalan di simulator default, ionq.simulator. Namun, Anda juga dapat menjalankannya pada prosesor perangkat keras IonQ, atau Quantum Processor Unit (QPU). Untuk berjalan di QPU IonQ, berikan ionq.qpu sebagai target argumen:

result = service.run(
    program=circuit,
    repetitions=100,
    target="ionq.qpu",
    timeout_seconds=500 # Set timeout to accommodate queue time on QPU
)

Catatan

Waktu yang diperlukan untuk menjalankan sirkuit pada QPU bergantung pada waktu antrean saat ini. Anda dapat melihat waktu antrean rata-rata untuk dengan target memilih bilah Penyedia ruang kerja Anda.

Sekali lagi, cara ini akan menampilkan objek cirq.Result.

print(result)

    b=1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010, 1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010

Model asinkron menggunakan Jobs

Untuk sirkuit yang berjalan lama, dapat berguna untuk menjalankannya secara asinkron. Metode ini service.create_job mengembalikan objek Job, yang dapat Anda gunakan untuk mendapatkan hasil setelah pekerjaan berjalan dengan sukses.

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

Untuk memeriksa status pekerjaan, gunakan job.status():

print(job.status())

'completed'

Untuk menunggu pekerjaan selesai dan kemudian mendapatkan hasilnya, gunakan panggilan pemblokiran job.results():

result = job.results()
print(result)

00: 0.5
11: 0.5

Catatan

Fungsi job.results() tidak akan menampilkan objek cirq.Result. Sebaliknya, fungsi tersebut akan menampilkan objek hasil yang khusus untuk simulator IonQ dan menggunakan probabilitas status, daripada data bidikan.

type(result)

cirq_ionq.results.SimulatorResult

Untuk mengubah ini menjadi objek cirq.Result, gunakan result.to_cirq_result():

print(result.to_cirq_result())

b=1110101111111110111000011101011111001100010000001011011101001111001111001101100111010000001100011100, 1110101111111110111000011101011111001100010000001011011101001111001111001101100111010000001100011100

Quantinuum

Jalankan pada Validator API

Untuk memeriksa sirkuit Anda sebelum menjalankannya di perangkat keras kuantum yang sebenarnya, Anda dapat menggunakan Quantinuum API Validator, quantinuum.sim.h1-1sc.

Tambahkan sel berikut yang mengirimkan pekerjaan untuk menjalankan sirkuit dengan 100 bidikan, atau pengulangan, menunggu hingga pekerjaan selesai, dan mengembalikan hasilnya:

result = service.run(
    program=circuit,
    repetitions=100,
    target="quantinuum.sim.h1-1sc"
)

Langkah ini akan memunculkan objek cirq.Result.

print(result)

    b=0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Anda dapat merencanakan hasilnya dalam histogram:

import pylab as pl

pl.hist(result.data)
pl.ylabel("Counts")
pl.xlabel("Result")

Saat melihat histogram, Anda mungkin memperhatikan bahwa generator angka acak kembali ke 0 sehingga tidak terlalu acak. Ini dikarenakan, saat API Validator memastikan bahwa kode Anda akan berjalan dengan sukses di perangkat keras Quantinuum, API juga akan kembali ke 0 untuk setiap pengukuran kuantum. Untuk generator angka acak nyata, Anda harus menjalankan sirkuit di perangkat keras kuantum.

Memperkirakan biaya pekerjaan

Sebelum menjalankan pekerjaan di perangkat keras kuantum yang sebenarnya, atau unit pemrosesan kuantum (QPU), Anda dapat memperkirakan biaya pelaksanaan. Untuk memperkirakan biaya menjalankan pekerjaan di QPU, Anda dapat menggunakan metode ini estimate_cost:

cost = service.estimate_cost(
    program=circuit,
    repetitions=100,
    target="quantinuum.qpu.h1-1"
)

print(f"Estimated cost: {cost.estimated_total}")

Estimated cost: 5.42

Ini mencetak perkiraan biaya dalam H-System Quantum Credits (HQC).

Untuk detail harga terbaru, lihat Harga Azure Quantum, atau lihat opsi harga di bilah Penyedia ruang kerja Anda. Untuk melihat status dan penggunaan kredit Anda saat ini, pilih Kredit dan kuota.

Menjalankan di Quantinuum QPU

Setelah berhasil berjalan di validator API dan memperkirakan biaya QPU, saatnya untuk menjalankan sirkuit Anda di perangkat keras.

Catatan

Waktu yang diperlukan untuk menjalankan sirkuit pada QPU bergantung pada waktu antrean saat ini. Anda dapat melihat waktu antrean rata-rata untuk dengan target memilih bilah Penyedia ruang kerja Anda.

Gunakan metode dan operasi run yang sama seperti yang telah Anda gunakan sebelumnya dengan API Validator untuk mengirimkan pekerjaan Anda dan menampilkan hasilnya:

result = service.run(
    program=circuit,
    repetitions=100,
    target="quantinuum.qpu.h1-1"
)

pl.hist(result.data)
pl.ylabel("Counts")
pl.xlabel("Result")

Anda dapat melihat bahwa hasilnya sekarang secara kasar dibagi antara 0 dan 1.

Alur kerja asinkron menggunakan Jobs

Untuk sirkuit yang berjalan lama, dapat berguna untuk menjalankannya secara asinkron. Metode ini service.create_job mengembalikan objek Job, yang dapat Anda gunakan untuk mendapatkan hasil setelah pekerjaan berjalan dengan sukses.

job = service.create_job(
    program=circuit,
    repetitions=100,
    target="quantinuum.qpu.h1-1"
)

Untuk memeriksa status pekerjaan, gunakan job.status():

print(job.status())

'Waiting'

Untuk menunggu pekerjaan selesai dan kemudian mendapatkan hasilnya, gunakan panggilan pemblokiran job.results():

result = job.results()
print(result)

{'m_b': ['11', '11', '00', '11', '00', '00', '00', '00', '11', '00', '00', '11', '00', '00', '00', '00', '11', '11', '11', '00', '11', '00', '00', '11', '11', '11', '11', '00', '00', '00', '00', '00', '00', '11', '11', '00', '11', '00', '11', '11', '00', '00', '00', '11', '11', '00', '00', '11', '11', '11', '00', '00', '11', '11', '11', '11', '00', '00', '11', '11', '00', '11', '11', '00', '00', '00', '11', '11', '11', '11', '11', '00', '00', '11', '00', '11', '11', '11', '11', '00', '11', '00', '00', '00', '01', '11', '11', '00', '00', '11', '11', '11', '11', '00', '00', '00', '11', '00', '11', '00']}

Catatan

Fungsi job.results() tidak akan menampilkan objek cirq.Result. Sebagai gantinya, fungsi akan menampilkan kamus hasil pengukuran bitstring yang diindeks oleh kunci pengukuran.

Penting

Mengirimkan beberapa sirkuit pada satu pekerjaan saat ini tidak didukung. Sebagai solusinya, Anda dapat memanggil backend.run metode untuk mengirimkan setiap sirkuit secara asinkron, lalu mengambil hasil setiap pekerjaan. Contohnya:

jobs = []
for circuit in circuits:
    jobs.append(backend.run(circuit, shots=N))

results = []
for job in jobs:
    results.append(job.result())

Langkah berikutnya

• Mulai cepat: Kirim sirkuit dengan Qiskit ke Azure Quantum.
• Mulai cepat: Kirim sirkuit dengan format khusus penyedia ke Azure Quantum.