Mulai menggunakan program Q# dan Visual Studio Code

Dalam artikel ini Anda akan menemukan langkah-langkah untuk menggunakan Kode VC untuk membuat dan mengirimkan pekerjaan komputasi kuantum Q#, Jupyter Notebook, atau Python ke Azure Quantum menggunakan Visual Studio Code.

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 Modern 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 Menguji dan men-debug atau Memigrasikan program Anda ke QDK Modern.

Menjalankan program Q#

  1. Untuk menguji jalankan program Anda secara lokal pada simulator bawaan, klik Jalankan dari daftar perintah di bawah ini @EntryPoint(), 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 bawah ini @EntryPoint(), 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.

Plot histogram frekuensi

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

  1. Pilih Tampilan -> Palet Perintah dan ketik "histogram" yang akan memunculkan opsi Q#: Jalankan file dan tampilkan histogram . Anda juga dapat mengklik Histogram dari daftar perintah di bawah ini @EntryPoint(). Pilih opsi ini untuk membuka jendela histogram Q#.

    Cuplikan layar file Q# di Visual Studio Code memperlihatkan tempat untuk 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.

Menyambungkan ke Azure Quantum dan mengirimkan pekerjaan Anda

Gunakan Quantum Workspaces bawaan untuk menyambungkan dan mengirimkan pekerjaan langsung dari Visual Studio Code. Untuk contoh ini, Anda akan mengirimkan pekerjaan ke simulator Rigetti.

  1. Di panel Explorer , perluas Quantum Workspaces.

    Cuplikan layar Visual Studio Code memperlihatkan cara memperluas panel Ruang Kerja Quantum.

  2. Pilih Tambahkan ruang kerja yang sudah ada dan ikuti perintah untuk menyambungkan ke direktori, langganan, dan ruang kerja pilihan Anda.

  3. Setelah tersambung, perluas ruang kerja Anda dan perluas penyedia Rigetti .

    Catatan

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

  4. Pilih rigetti.sim.qvm sebagai .target

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

  5. 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.

  6. Tambahkan nama untuk mengidentifikasi pekerjaan.

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

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

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

  10. 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 Q# Jupyter Notebook 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 Modern di Visual Studio Code.

Jalankan dan uji program Anda di simulator lokal

  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 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 Studio Code untuk informasi penyiapan.

  3. Di sel pertama buku catatan, jalankan

    import qsharp
    import azure.quantum
    
    • Modul mengaktifkan qsharp%%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:

    %%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]]
    

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()
    
    {'Histogram': ['[0, 0, 0, 0]',
      0.3,
      '[1, 0, 0, 0]',
      0.1,
      '[1, 1, 1, 1]',
      0.3,
      '[0, 1, 1, 1]',
      0.3]}
    
  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
    

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 Modern 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 proyek Anda sebagai source.qs.

    Catatan

    Perhatikan bahwa kode Q# ini tidak memiliki @EntryPoint fungsi seperti program Q# (lihat Mengirimkan pekerjaan Q# ke Azure Quantum), tetapi memerlukan namespace layanan, tidak seperti Jupyter Notebook (lihat Mengirimkan pekerjaan Jupyter Notebook ke Azure Quantum).

    namespace Sample {
    
      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 yang sama, 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 jalankan target operasi pada simulator lokal. Operasi ini dipanggil oleh <namespace> layanan.<operation_name( )>, dan dalam hal ini, Anda meneruskan jumlah bit acak untuk dikembalikan.

    qsharp.init(project_root = '/MyProjectRootFolder')
    print(qsharp.eval("Sample.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("Sample.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 profil Dasar. Untuk informasi selengkapnya, lihat Jenis profil di Azure Quantum.

Catatan

Untuk program Q# saja di Visual Studio Code, VISUAL Studio Code mengatur profil Dasar secara otomatis.

  1. init Gunakan metode untuk mengatur profil:

    qsharp.init(target_profile=qsharp.TargetProfile.Base)
    
  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("Sample.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 nilai saja dan menampilkannya:

    resultList = results.get("Histogram")
    for x in resultList:
        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
    

Langkah berikutnya