Mulai menggunakan sesi

Contoh ini memperlihatkan cara membuat sesi dengan Q# kode sebaris menggunakan Jupyter Notebook di Visual Studio Code. Anda juga dapat membuat sesi menggunakan program Python yang memanggil program yang berdekatan Q# .

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 buku catatan, jalankan

   import azure.quantum
   
   workspace = azure.quantum.Workspace(
       resource_id = "", # add your resource ID
       location = "", # add your location, for example "westus"
   )
   

4. Klik + Kode untuk menambahkan sel baru di buku catatan dan mengimpor qsharp Python SDK.

   import qsharp
   

5. Pilih kuantum target pilihan Anda. Dalam contoh ini, Anda menggunakan simulator IonQ sebagai target.

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

6. Pilih konfigurasi target profil, baik Base, , Adaptive_RIatau Unrestricted.

   qsharp.init(target_profile=qsharp.TargetProfile.Base) # or qsharp.TargetProfile.Adaptive_RI, qsharp.TargetProfile.Unrestricted
   

   Catatan

   Adaptive_RItarget pekerjaan profil saat ini didukung di Quantinuum targets. Untuk informasi selengkapnya, lihat Komputasi kuantum hibrid terintegrasi.

7. Tulis program Anda Q# . Misalnya, program berikut Q# menghasilkan bit acak. Untuk mengilustrasikan penggunaan argumen input, program ini mengambil bilangan bulat, n, dan array sudut, angle, sebagai input.

   %%qsharp
   import Std.Measurement.*;
   import Std.Arrays.*;
   
   operation GenerateRandomBits(n: Int, angle: Double[]) : Result[] {
      use qubits = Qubit[n]; // n parameter as the size of the qubit array
      for q in qubits {
          H(q);
      }
      R(PauliZ, angle[0], qubits[0]); // arrays as entry-points parameters
      R(PauliZ, angle[1], qubits[1]);
      let results = MeasureEachZ(qubits);
      ResetAll(qubits);
      return results;
   }
   

8. Selanjutnya, Anda membuat sesi. Katakanlah Anda ingin menjalankan GenerateRandomBit operasi tiga kali, jadi Anda menggunakan target.submit untuk mengirimkan Q# operasi dengan target data dan Anda mengulangi kode tiga kali - dalam skenario dunia nyata, Anda mungkin ingin mengirimkan program yang berbeda alih-alih kode yang sama.

   angle = [0.0, 0.0]
   with target.open_session(name="Q# session of three jobs") as session:
       target.submit(input_data=qsharp.compile(f"GenerateRandomBits(2, {angle})"), name="Job 1", shots=100) # First job submission
       angle[0] += 1
       target.submit(input_data=qsharp.compile(f"GenerateRandomBits(2, {angle})"), name="Job 2", shots=100) # Second job submission
       angle[1] += 1
       target.submit(input_data=qsharp.compile(f"GenerateRandomBits(2, {angle})"), name="Job 3", shots=100) # Third job submission
   
   session_jobs = session.list_jobs()
   [session_job.details.name for session_job in session_jobs]
   

   Penting

   Saat meneruskan argumen sebagai parameter ke pekerjaan, argumen tersebut Q# diformat ke dalam ekspresi saat memanggil qsharp.compile. Ini berarti Bahwa Anda perlu berhati-hati untuk memformat argumen Anda sebagai Q# objek. Dalam contoh ini, karena array di Python sudah dicetak sebagai [item0, item1, ...], argumen input cocok dengan Q# pemformatan. Untuk struktur data Python lainnya, Anda mungkin memerlukan lebih banyak penanganan untuk mendapatkan nilai string yang Q# disisipkan ke dalam dengan cara yang kompatibel.

9. Setelah membuat sesi, Anda dapat menggunakan workspace.list_session_jobs untuk mengambil daftar semua pekerjaan dalam sesi. Untuk informasi selengkapnya, lihat Cara mengelola sesi.

1. Pertama, Anda perlu mengimpor modul tambahan dari azure-quantum dan qiskit. Selanjutnya, buat provider objek dengan informasi ruang kerja Quantum Anda.

   from qiskit import QuantumCircuit
   from azure.quantum import Workspace
   from azure.quantum.qiskit import AzureQuantumProvider
   
   workspace = Workspace(
               resource_id = "", # add your resource ID
               location = "") # add your location
   
   provider = AzureQuantumProvider(workspace)
   

2. Tulis sirkuit kuantum Anda. Misalnya, sirkuit berikut menghasilkan bit acak.

   circuit = QuantumCircuit(2, 2)
   circuit.name = "GenerateRandomBit"
   circuit.h(0)
   circuit.cx(0,1)
   circuit.measure([0,1], [0,1])
   circuit.draw()
   

3. Selanjutnya, buat instans backend dengan kuantum target pilihan Anda. Dalam contoh ini, atur simulator IonQ sebagai target.

   backend = provider.get_backend("ionq.simulator")
   

4. Selanjutnya, buat sesi. Katakanlah Anda ingin menjalankan sirkuit kuantum Anda tiga kali, jadi Anda menggunakan backend.run untuk mengirimkan sirkuit Qiskit, dan Anda mengulangi kode tiga kali - dalam skenario dunia nyata, Anda mungkin ingin mengirimkan program yang berbeda alih-alih kode yang sama. Anda dapat menggunakan workspace.list_session_jobs untuk mengambil daftar semua pekerjaan dalam sesi. Untuk informasi selengkapnya, lihat Cara mengelola sesi.

   with backend.open_session(name="Qiskit Session") as session:
       job1 = backend.run(circuit=circuit, shots=100, job_name="Job 1") # First job submission
       job1.wait_for_final_state()
       job2 = backend.run(circuit=circuit, shots=100, job_name="Job 2") # Second job submission
       job2.wait_for_final_state()
       job3 = backend.run(circuit=circuit, shots=100, job_name="Job 3") # Third job submission
       job3.wait_for_final_state()
   
   session_jobs = session.list_jobs()
   [session_job.details.name for session_job in session_jobs]
   

1. Pertama, tulis sirkuit kuantum Anda. Misalnya, sirkuit berikut menghasilkan bit acak.

   import cirq
   
   q0 = cirq.LineQubit(0)
   q1 = cirq.LineQubit(1)
   circuit = cirq.Circuit(
       cirq.H(q0),  # H gate
       cirq.CNOT(q0, q1),
       cirq.measure(q0, key='q0'),
       cirq.measure(q1, key='q1')
   )
   print(circuit)
   

2. Kemudian, buat service objek dengan informasi ruang kerja Quantum Anda.

   from azure.quantum.cirq import AzureQuantumService
   
   service = AzureQuantumService(
               resource_id = "", # add your resource ID
               location = "") # add your location
   

3. Pilih kuantum target pilihan Anda. Dalam contoh ini, Anda menggunakan simulator IonQ sebagai target.

   Catatan

   Sirkuit sirkuit hanya dapat menggunakan IonQ atau Quantinuum targets.

   target = service.get_target("ionq.simulator")
   

4. Selanjutnya, Anda membuat sesi. Katakanlah Anda ingin menjalankan sirkuit kuantum Anda tiga kali, jadi Anda menggunakan target.submit untuk mengirimkan sirkuit Cirq, dan Anda mengulangi kode tiga kali - dalam skenario dunia nyata, Anda mungkin ingin mengirimkan program yang berbeda alih-alih kode yang sama.. Anda dapat menggunakan workspace.list_session_jobs untuk mengambil daftar semua pekerjaan dalam sesi. Untuk informasi selengkapnya, lihat Cara mengelola sesi.

   with target.open_session(name="Cirq Session") as session:
       target.submit(program=circuit, name="Job 1", repetitions=100) # First job submission
       target.submit(program=circuit, name="Job 2", repetitions=100) # Second job submission
       target.submit(program=circuit, name="Job 3", repetitions=100) # Third job submission
   
   session_jobs = session.list_jobs()
   [session_job.details.name for session_job in session_jobs]