Bagikan melalui

Cara mengirimkan program Q# dengan Visual Studio Code

  • Artikel

Pelajari cara menggunakan Visual Studio Code untuk membuat dan mengirimkan program Q# ke perangkat keras kuantum nyata. Anda dapat mengirimkan pekerjaan komputasi kuantum ke Azure Quantum sebagai program Q# mandiri, menggabungkan Q# dengan Python dalam proyek Q#, dan menjalankan Jupyter Notebook.

Mengirimkan pekerjaan Q# ke Azure Quantum

Pelajari cara menggunakan Visual Studio Code untuk menjalankan, men-debug, dan mengirimkan program Q# ke Azure Quantum.

Prasyarat

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

Memuat program sampel Q#

  1. Di Visual Studio Code, pilih File > Teks Baru dan simpan file sebagai RandomNum.qs.

  2. Buka RandomNum.qs dan ketik sample, lalu pilih Sampel Bit Acak dari daftar opsi dan simpan file.

    Cuplikan layar file Q# di Visual Studio Code memperlihatkan daftar sampel kode saat menulis sampel kata dalam file.

Catatan

Anda juga dapat membuka file Q# Anda sendiri. Jika Anda menjalankan program Q# yang lebih lama dan mengalami kesalahan, lihat Pengujian dan penelusuran kesalahan.

Menjalankan program Q#

  1. Untuk menguji jalankan program Anda secara lokal pada simulator bawaan, klik Jalankan dari daftar perintah di samping operasi titik masuk, atau tekan Ctrl+F5. Output Anda akan muncul di konsol debug.

  2. Untuk men-debug program Anda sebelum mengirimkannya ke Azure Quantum, klik Debug dari daftar perintah di samping operasi titik masuk, atau tekan F5. Gunakan kontrol penelusuran kesalahan di bagian atas untuk melangkahi, masuk, dan keluar dari kode. Untuk informasi selengkapnya tentang penelusuran kesalahan program Q#, lihat Pengujian dan penelusuran kesalahan.

    Cuplikan layar file Q# di Visual Studio Code memperlihatkan tempat menemukan lensa kode dengan perintah jalankan dan debug.

Memvisualisasikan histogram frekuensi

Histogram frekuensi mewakili distribusi hasil yang diperoleh dari menjalankan program kuantum beberapa kali, atau "bidikan". Setiap bilah dalam histogram sesuai dengan kemungkinan hasil, dan tingginya mewakili berapa kali hasil tersebut diamati. Histogram frekuensi membantu memvisualisasikan distribusi probabilitas hasil ini.

  1. Pilih Tampilkan -> Palet Perintah dan ketik "histogram" yang harus memunculkan opsi Q#: Jalankan file dan tampilkan histogram . Anda juga dapat mengklik Histogram dari daftar perintah di samping operasi titik masuk. Pilih opsi ini untuk membuka jendela histogram Q#.

    Cuplikan layar file Q# di Visual Studio Code memperlihatkan tempat menemukan lensa kode dengan perintah histogram.

  2. Masukkan sejumlah bidikan untuk menjalankan program, misalnya, 100 bidikan, dan tekan Enter. Histogram akan ditampilkan di jendela histogram Q#.

  3. Klik ikon pengaturan kiri atas untuk menampilkan opsi.

    Cuplikan layar jendela histogram Q# di Visual Studio Code memperlihatkan cara menampilkan pengaturan.

  4. Klik bilah untuk menampilkan persentase hasil tersebut. Dalam hal ini ada dua kemungkinan hasil, 0 dan 1, dan persentase setiap hasil mendekati 50%.

    Cuplikan layar jendela histogram Q# di Visual Studio Code.

Tip

Anda dapat memperbesar histogram menggunakan roda gulir mouse atau gerakan trackpad. Saat diperbesar, Anda dapat menggeser bagan dengan menekan 'Alt' saat menggulir.

Memvisualisasikan sirkuit kuantum

Diagram sirkuit kuantum adalah representasi visual dari operasi kuantum. Mereka menunjukkan aliran qubit melalui program kuantum, termasuk gerbang dan pengukuran yang diterapkan pada mereka. Untuk informasi selengkapnya, lihat Diagram sirkuit Quantum di Visual Studio Code.

  1. Pilih Lihat -> Palet Perintah dan ketik "sirkuit" yang harus memunculkan opsi Q#: Tampilkan sirkuit . Anda juga dapat mengklik Sirkuit dari daftar perintah di samping operasi titik masuk.

    Cuplikan layar file Q# di Visual Studio Code memperlihatkan tempat menemukan perintah sirkuit lensa kode.

  2. Sirkuit ditampilkan di jendela sirkuit Q#. Diagram sirkuit memperlihatkan satu daftar qubit yang diinisialisasi ke status |0⟩. Kemudian, gerbang Hadamard, H, diterapkan ke qubit, diikuti oleh operasi pengukuran, yang diwakili oleh simbol meter. Untuk informasi selengkapnya, lihat Konvensi sirkuit Quantum.

    Cuplikan layar jendela sirkuit Q# memperlihatkan diagram sirkuit yang dihasilkan untuk operasi bit acak.

Menyambungkan ke Azure Quantum dan mengirimkan pekerjaan Anda

Anda dapat menyambungkan dan mengirimkan pekerjaan langsung dari Visual Studio Code. Untuk contoh ini, Anda akan mengirimkan pekerjaan ke simulator Rigetti.

  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.

    Catatan

    Jika Anda memiliki string koneksi, Anda dapat memilih String koneksi dan menempelkan string koneksi yang sesuai dengan ruang kerja Azure Quantum Anda. Untuk informasi selengkapnya, lihat Menyambungkan ke ruang kerja Quantum menggunakan string koneksi.

  3. Setelah Anda tersambung, di panel Explorer , perluas Ruang Kerja Quantum.

  4. Perluas ruang kerja Anda dan perluas penyedia Rigetti .

    Catatan

    Jika ada masalah saat menyambungkan ke Azure Quantum, ikon peringatan akan ditampilkan di samping nama ruang kerja. Arahkan mouse ke atas nama ruang kerja untuk menampilkan informasi kesalahan.

  5. Pilih rigetti.sim.qvm sebagai target.

    Cuplikan layar Visual Studio Code memperlihatkan cara memilih simulator Rigetti sebagai target.

  6. Pilih ikon putar di sebelah kanan target nama untuk mulai mengirimkan program Q# saat ini. Jika Anda mendapatkan popup, pilih Ubah profil QIR target dan lanjutkan.

    Cuplikan layar Visual Studio Code memperlihatkan cara menjalankan simulator Rigetti sebagai target.

  7. Tambahkan nama untuk mengidentifikasi pekerjaan.

  8. Tambahkan jumlah bidikan, atau berapa kali program dijalankan.

  9. Tekan Enter untuk mengirimkan pekerjaan. Status pekerjaan akan ditampilkan di bagian bawah layar.

  10. Perluas Pekerjaan dan arahkan mouse ke atas pekerjaan Anda, yang menampilkan waktu dan status pekerjaan Anda.

  11. Untuk melihat hasilnya, pilih ikon cloud di samping nama pekerjaan untuk mengunduh hasil dari penyimpanan ruang kerja Anda dan menampilkannya di Visual Studio Code.

    Cuplikan layar Visual Studio Code memperlihatkan cara mengunduh dan melihat hasil pekerjaan kuantum Anda.

Mengirimkan pekerjaan Jupyter Notebooks ke Azure Quantum

Pelajari cara menggunakan Visual Studio Code untuk menjalankan, men-debug, dan mengirimkan Notebook Q# Jupyter ke Azure Quantum. Langkah-langkah dalam artikel ini juga berlaku untuk Jupyter Notebooks di server Atau notebook Jupyter lokal Anda di portal Azure Quantum.

Prasyarat

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

Jalankan dan uji program Anda di simulator lokal

  1. Di Visual Studio Code, pilih Tampilkan Palet Perintah dan pilih Buat: Notebook Jupyter > Baru.

  2. Di kanan atas, VISUAL Code akan mendeteksi dan menampilkan versi Python dan lingkungan Python virtual yang dipilih untuk notebook. Jika Anda memiliki beberapa lingkungan Python, Anda mungkin perlu memilih kernel menggunakan pemilih kernel di kanan atas. Jika tidak ada lingkungan yang terdeteksi, lihat Jupyter Notebooks di VISUAL Code untuk informasi penyiapan.

  3. Di sel pertama notebook, jalankan kode Python berikut untuk mengimpor modul yang diperlukan:

    import qsharp
import azure.quantum
    • Modul qsharp mengaktifkan %%qsharp perintah ajaib yang memungkinkan Anda memasukkan kode Q# langsung ke dalam sel.
    • Modul ini azure-quantum menyediakan konektivitas ke ruang kerja Azure Quantum Anda.

    Catatan

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

  4. Tambahkan sel lain dan masukkan kode Q# ini yang mengembalikan jumlah bit acak yang ditentukan pengguna:

    Catatan

    Perhatikan bahwa segera setelah Anda mengetikkan perintah %%qsharpajaib , sel buku catatan mengubah jenis dari Python ke Q#.

    %%qsharp

operation Random() : Result {
    use q = Qubit();
    H(q);
    let result = M(q);
    Reset(q);
    return result
}

operation RandomNBits(N: Int): Result[] {
    mutable results = [];
    for i in 0 .. N - 1 {
        let r = Random();
        set results += [r];
    }
    return results
}

  5. Untuk menguji operasi, Anda dapat menggunakan eval metode , yang dapat memanggil operasi Q# apa pun yang sebelumnya ditentukan dalam buku catatan:

    qsharp.eval("RandomNBits(4)")

    [Zero, One, One, Zero]

  6. Untuk menjalankan program Anda ke simulator lokal, gunakan metode .run shotsTentukan , atau berapa kali untuk menjalankan program, dan simulator mengembalikan hasilnya sebagai daftar Python.

    qsharp.run("RandomNBits(4)", shots=10)

    [[One, One, One, One],
[Zero, Zero, One, Zero],
[One, Zero, Zero, One],
[Zero, One, Zero, Zero],
[One, Zero, One, One],
[One, Zero, One, Zero],
[One, One, One, Zero],
[One, One, One, One],
[Zero, Zero, Zero, One],
[One, Zero, Zero, One]]

Memvisualisasikan sirkuit kuantum

Anda dapat memvisualisasikan sirkuit kuantum menggunakan qsharp-widgets paket. Paket ini menyediakan widget yang merender diagram sirkuit kuantum sebagai gambar SVG. Untuk informasi selengkapnya, lihat Diagram sirkuit Quantum dengan Jupyter Notebooks.

Tambahkan kode berikut ke sel baru untuk memvisualisasikan sirkuit:

from qsharp_widgets import Circuit

Circuit(qsharp.circuit("RandomNBits(4)"))

Cuplikan layar Jupyter Notebook memperlihatkan cara memvisualisasikan sirkuit untuk operasi Q#.

Untuk informasi selengkapnya, lihat Konvensi sirkuit Quantum.

Mengkompilasi pekerjaan Anda menggunakan profil Dasar

Ketika Anda menjalankan program pada simulator kuantum lokal, Anda dapat mengirimkan semua jenis program Q#. Namun, perangkat keras targets Azure Quantum belum mendukung kemampuan penuh yang diperlukan untuk menjalankan semua program Q#. Untuk mengkompilasi dan mengirimkan program Q# ke Azure Quantum, Anda perlu mengatur profil Anda target untuk memberi tahu Q# kemampuan mana yang didukung perangkat keras Anda target . Saat ini, itu adalah profil Dasar. Untuk informasi selengkapnya, lihat Jenis profil di Azure Quantum.

Untuk menginisialisasi ulang penerjemah Q# dan mengkompilasi program Anda dengan profil dasar:

  1. init Gunakan metode untuk mengatur profil:

    qsharp.init(target_profile=qsharp.TargetProfile.Base)

  2. Karena Anda menginisialisasi ulang penerjemah, Anda perlu menjalankan kode Anda lagi dengan profil baru:

    %%qsharp

operation Random() : Result {
    use q = Qubit();
    H(q);
    let result = M(q);
    Reset(q);
    return result
}

operation RandomNBits(N: Int): Result[] {
    mutable results = [];
    for i in 0 .. N - 1 {
        let r = Random();
        set results += [r];
    }
    return results
}

  3. Selanjutnya, gunakan compile metode untuk menentukan operasi atau fungsi yang merupakan titik masuk ke program Anda. Ini mengkompilasi kode Anda ke dalam format QIR, yang kemudian dapat dikirimkan ke perangkat keras kuantum apa pun:

    MyProgram = qsharp.compile("RandomNBits(4)")

Menyambungkan ke Azure Quantum dan mengirimkan pekerjaan Anda

Sekarang setelah program Anda dikompilasi ke dalam format yang benar, buat azure.quantum.Workspace objek untuk menyambungkan ke Azure Quantum. Anda akan menggunakan ID Sumber Daya ruang kerja Azure Quantum Anda untuk menyambungkan. ID Sumber Daya dan lokasi dapat disalin dari halaman gambaran umum ruang kerja Anda di portal Azure.

  1. Di sel baru, isi ID sumber daya dan lokasi Anda dari ruang kerja Azure Quantum Anda:

    MyWorkspace = azure.quantum.Workspace(
    resource_id = "MyResourceID",
    location = "MyLocation"
)

  2. get_targets Gunakan metode untuk melihat perangkat keras targets yang tersedia di ruang kerja Anda:

    MyTargets = MyWorkspace.get_targets()
print("This workspace's targets:")
MyTargets

  3. rigetti.sim.qvmtargetPilih :

    MyTarget = MyWorkspace.get_targets("rigetti.sim.qvm")

  4. Terakhir, gunakan submit metode untuk mengirimkan program Anda dengan parameternya dan menampilkan hasilnya:

    job = MyTarget.submit(MyProgram, "MyQuantumJob", shots=100)
job.get_results()

    {'[0, 1, 1, 1]': 0.08,
 '[1, 1, 0, 0]': 0.1,
 '[0, 0, 1, 0]': 0.04,
 '[0, 1, 0, 0]': 0.05,
 '[1, 0, 1, 0]': 0.05,
 '[1, 0, 0, 0]': 0.07,
 '[0, 1, 0, 1]': 0.07,
 '[1, 0, 1, 1]': 0.07,
 '[0, 0, 0, 0]': 0.08,
 '[1, 1, 1, 0]': 0.05,
 '[0, 0, 0, 1]': 0.1,
 '[0, 0, 1, 1]': 0.04,
 '[0, 1, 1, 0]': 0.09,
 '[1, 0, 0, 1]': 0.04,
 '[1, 1, 1, 1]': 0.05,
 '[1, 1, 0, 1]': 0.02}

  5. Semua properti pekerjaan dapat diakses di job.details, misalnya:

    print(job.details)
print("\nJob name:", job.details.name)
print("Job status:", job.details.status)
print("Job ID:", job.details.id)

    {'additional_properties': {'isCancelling': False}, 'id': '0150202e-9638-11ee-be2f-b16153380354', 'name': 'MyQuantumJob', 'provider_id': 'rigetti'...}
Job name: MyQuantumJob
Job status: Succeeded
Job ID: 0150202e-9638-11ee-be2f-b16153380354

Detail pekerjaan tambahan

Paket azure.quantum Python menyertakan metode tambahan untuk menampilkan data pekerjaan yang lebih rinci.

  • job.get_results_histogram(): Metode ini mengembalikan kamus hasil dan jumlah bidikan untuk setiap pengukuran unik. Misalnya, hasil untuk pekerjaan sebelumnya adalah

    print(job.get_results_histogram()) 

    {   
    '[0, 1, 1, 1]' : {'Outcome' : [0, 1, 1, 1], 'Count' : 8},  
    '[1, 1, 0, 0]' : {'Outcome' : [1, 1, 0, 0], 'Count' : 10},
    '[0, 0, 1, 0]' : {'Outcome' : [0, 0, 1, 0], 'Count' : 4},
    '[0, 1, 0, 0]' : {'Outcome' : [0, 1, 0, 0], 'Count' : 5},
    '[1, 0, 1, 0]' : {'Outcome' : [1, 0, 1, 0], 'Count' : 5},  
    '[1, 0, 0, 0]' : {'Outcome' : [1, 0, 0, 0], 'Count' : 7},
    '[0, 1, 0, 1]' : {'Outcome' : [0, 1, 0, 1], 'Count' : 7},
    '[1, 0, 1, 1]' : {'Outcome' : [1, 0, 1, 1], 'Count' : 7},
    '[0, 0, 0, 0]' : {'Outcome' : [0, 0, 0, 0], 'Count' : 8},  
    '[1, 1, 1, 0]' : {'Outcome' : [1, 1, 1, 0], 'Count' : 5},
    '[0, 0, 0, 1]' : {'Outcome' : [0, 0, 0, 1], 'Count' : 10},
    '[0, 0, 1, 1]' : {'Outcome' : [0, 0, 1, 1], 'Count' : 4},
    '[0, 1, 1, 0]' : {'Outcome' : [0, 1, 1, 0], 'Count' : 9},  
    '[1, 0, 0, 1]' : {'Outcome' : [1, 0, 0, 1], 'Count' : 4},
    '[1, 1, 1, 1]' : {'Outcome' : [1, 1, 1, 1], 'Count' : 5},
    '[1, 1, 0, 1]' : {'Outcome' : [1, 1, 0, 1], 'Count' : 2}
}

  • job.get_results_shots() : Metode ini mengembalikan daftar setiap hasil bidikan. Misalnya, hasil untuk pekerjaan sebelumnya adalah

    print(job.get_results_shots()) 

    [ [0, 1, 1, 1], [1, 0, 1, 1], [0, 0, 1, 1], [1, 1, 0, 1], [1, 0, 0, 0], [1, 0, 1, 1], [1, 1, 0, 1], ...]

Mengirimkan Python dengan pekerjaan Q# ke Azure Quantum

Pelajari cara menggunakan Visual Studio Code untuk menulis program Python yang memanggil operasi Q#, menyambungkan ke Azure menggunakan perintah Python atau Azure CLI, dan mengirimkan pekerjaan Anda.

Prasyarat

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

Membuat dan mengimpor operasi Q# Anda

Dengan paket ini qsharp , Anda dapat menyimpan fungsi dan operasi dalam file Q# dan membuat proyek Q# yang memungkinkan Anda memanggil salah satunya dari kode Python Anda. Ini sangat membantu ketika Anda perlu meluncurkan program yang mengambil parameter input.

  1. Ikuti langkah-langkah untuk membuat proyek Q#.

  2. Buka file teks baru, tambahkan kode Q# berikut yang mengembalikan jumlah bit acak yang ditentukan pengguna, dan simpan file ke direktori /src dalam proyek Anda sebagai Source.qs.

    
    operation Random() : Result {
    use q = Qubit();
    H(q);
    let result = M(q);
    Reset(q);
    return result
}

operation RandomNBits(N: Int): Result[] {
    mutable results = [];
    for i in 0 .. N - 1 {
        let r = Random();
        set results += [r];
    }
    return results
}

  3. Di folder akar proyek (dengan file qsharp.json ), buka file lain dan simpan sebagai randomNum.py.

  4. Tambahkan kode berikut untuk mengimpor qsharp modul dan azure.quantum .

    import qsharp
import azure.quantum

  5. Selanjutnya, tambahkan kode untuk menentukan folder akar proyek Q# dan uji target operasi pada simulator lokal. Operasi ini dipanggil oleh <namespace> layanan.<operation_name( )>, dan dalam hal ini, Anda meneruskan jumlah bit acak untuk dikembalikan.

    Catatan

    Karena tidak ada namespace yang ditentukan dalam Source.qs, pengkompilasi menggunakan nama file sebagai namespace default - Source.RandomNBits(). Untuk informasi selengkapnya, lihat Proyek dan namespace implisit.

    qsharp.init(project_root = '../MyProjectRootFolder')
print(qsharp.eval("Source.RandomNBits(4)"))

    [Zero, One, One, Zero]

  6. Anda juga dapat menguji operasi dengan run metode , yang melewati parameter tambahan shots , dan mengembalikan hasilnya dalam daftar Python. Di randomNum.py, ganti pernyataan cetak sebelumnya dengan yang berikut ini:

    result = qsharp.run("Source.RandomNBits(4)", shots=10)
for x in result:
    print(x)

    [[One, One, One, One],
[Zero, Zero, One, Zero],
[One, Zero, Zero, One],
[Zero, One, Zero, Zero],
[One, Zero, One, One],
[One, Zero, One, Zero],
[One, One, One, Zero],
[One, One, One, One],
[Zero, Zero, Zero, One],
[One, Zero, Zero, One]]

Mengkompilasi pekerjaan Anda menggunakan profil Dasar

Ketika Anda menjalankan program pada simulator kuantum lokal, Anda dapat mengirimkan semua jenis program Q#. Namun, perangkat keras targets Azure Quantum belum mendukung kemampuan penuh yang diperlukan untuk menjalankan semua program Q#. Untuk mengkompilasi dan mengirimkan program Q# ke Azure Quantum, Anda perlu mengatur profil Anda target untuk memberi tahu Q# kemampuan mana yang didukung perangkat keras Anda target . Saat ini, itu adalah Base profil atau Adpative_RI . Untuk informasi selengkapnya, lihat Jenis profil di Azure Quantum.

Catatan

Untuk Q# hanya program di VISUAL Code, VISUAL Code mengatur Base profil secara otomatis.

  1. init Gunakan metode untuk mengatur profil:

    qsharp.init(project_root = '../MyProjectRootFolder', target_profile=qsharp.TargetProfile.Base)

    Catatan

    Karena Anda menginisialisasi ulang status qsharp, Anda perlu mengatur project_root parameter lagi sehingga pengompilasi tahu di mana menemukan RandomNBits operasi. Ini juga bisa dilakukan pada langkah 5 dari prosedur sebelumnya.

  2. Kemudian gunakan compile metode untuk menentukan operasi atau fungsi yang merupakan titik masuk ke program Anda. Program yang dikompilasi kemudian dapat dikirimkan ke perangkat keras kuantum apa pun:

    MyProgram = qsharp.compile("Source.RandomNBits(4)")

Menyambungkan ke Azure Quantum dan mengirimkan pekerjaan Anda

Anda dapat terhubung ke Azure Quantum dan mengirimkan pekerjaan Anda menggunakan objek yang dibuat Workspace Python, atau menyambungkan dan mengirimkan pekerjaan Anda menggunakan Azure CLI. Menggunakan Azure CLI mengharuskan Anda menyimpan program yang dikompilasi sebagai file teks dan mengirimkan file tersebut menggunakan perintah CLI.

Sekarang setelah program Anda dikompilasi ke dalam format yang benar, buat azure.quantum.Workspace objek untuk menyambungkan ke Azure Quantum. Anda akan menggunakan ID Sumber Daya ruang kerja Azure Quantum Anda untuk menyambungkan. ID Sumber Daya dan lokasi dapat disalin dari halaman gambaran umum ruang kerja Anda di portal Azure.

  1. Tambahkan kode berikut ke randomNum.py, mengisi ID sumber daya dan lokasi Anda dari ruang kerja Azure Quantum Anda:

    workspace = azure.quantum.Workspace(
    resource_id = "MyResourceID",
    location = "MyLocation"
)

  2. get_targets Gunakan metode untuk menampilkan perangkat keras targets yang tersedia di ruang kerja Anda:

    MyTargets = workspace.get_targets()
print("This workspace's targets:")
for x in MyTargets:
    print(x)

  3. rigetti.sim.qvmtargetPilih :

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

  4. Terakhir, gunakan submit metode untuk mengirimkan program Anda dengan parameternya. Hasil pekerjaan dikembalikan sebagai kamus Python.

    job = MyTarget.submit(MyProgram, "MyPythonJob", shots=100)
results = job.get_results()
print("\nResults: ", results)

  5. Untuk mengekstrak hanya nilai dan menampilkannya:

    for x in results:
    print(x)

    [0, 0, 0, 0]
0.3
[1, 0, 0, 0]
0.1
[1, 1, 1, 1]
0.3
[0, 1, 1, 1]
0.3

  6. Semua properti pekerjaan dapat diakses di job.details, misalnya:

    print(job.details)
print("\nJob name:", job.details.name)
print("Job status:", job.details.status)
print("Job ID:", job.details.id)

    {'additional_properties': {'isCancelling': False}, 'id': '0fc396d2-97dd-11ee-9958-6ca1004ff31f', 'name': 'MyPythonJob', 'provider_id': 'rigetti'...}
Job name: MyPythonJob
Job status: Succeeded
Job ID: fc396d2-97dd-11ee-9958-6ca1004ff31f

Detail pekerjaan tambahan

Paket azure.quantum Python menyertakan metode tambahan untuk menampilkan data pekerjaan yang lebih rinci.

  • job.get_results_histogram(): Metode ini mengembalikan kamus hasil dan jumlah bidikan untuk setiap pengukuran unik. Misalnya, hasil untuk pekerjaan sebelumnya adalah

    results = job.get_results_histogram()
for x in results.items():
    print(x)

    {   
    '[0, 0, 0, 0]' : {'Outcome' : [0, 0, 0, 0], 'Count' : 30},  
    '[1, 0, 0, 0]' : {'Outcome' : [1, 0, 0, 0], 'Count' : 10},
    '[1, 1, 1, 1]' : {'Outcome' : [1, 1, 1, 1], 'Count' : 30},
    '[0, 1, 1, 1]' : {'Outcome' : [0, 1, 1, 1], 'Count' : 30}
}

  • job.get_results_shots() : Metode ini mengembalikan daftar setiap hasil bidikan. Misalnya, hasil untuk pekerjaan sebelumnya adalah

    print(job.get_results_shots()) 

    [ [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1], [1, 1, 1, 1], [1, 0, 0, 0], [0, 1, 1, 1], [0, 0, 0, 0], ...]

Konten terkait