Cara menginstal dan menjalankan QDK simulator kuantum

Microsoft Quantum Development Kit (QDK) mencakup satu set simulator kuantum yang dapat Anda akses dari Visual Studio Code ekstensi (VS Code) dan QDKPython paket. Simulator ini memungkinkan Anda menguji bagaimana program kuantum Anda berjalan pada perangkat keras kuantum nyata. Artikel ini menjelaskan cara menginstal simulator dan cara menjalankan simulasi dasar di Jupyter Notebook dan VS Code.

QDK mencakup empat simulator kuantum:

  • Simulator jarang
  • Simulator Clifford
  • Simulator GPU
  • Simulator CPU

Untuk informasi selengkapnya tentang QDK simulator kuantum, lihat Gambaran umum simulator kuantum di QDK.

Prasyarat

Untuk mengikuti langkah-langkah dalam artikel ini, Anda perlu menginstal alat berikut:

Instal simulator

Keempat simulator tersedia dalam QDKPython paket, tetapi hanya simulator jarang yang tersedia di QDKVS Code ekstensi.

Untuk menggunakan simulator sparse di ekstensi VS Code, instal ekstensi QDK untuk VS Code.

Untuk menggunakan simulator kuantum di Python dan Jupyter Notebook, instal versiPythonqdkterbaru paket dengan jupyter tambahan:

pip install --upgrade "qdk[jupyter]"

Ekstra jupyter tidak diperlukan untuk menggunakan simulator, tetapi menginstal modul qdk.widgets. Modul widgets memungkinkan Anda membuat visualisasi dari hasil simulasi Anda di Jupyter Notebook.

Jalankan simulasi menggunakan QDK ekstensi untuk VS Code

Ekstensi QDK untuk VS Code hanya menyediakan simulator sparse. Untuk menjalankan program Anda pada simulator sparse di VS Code, buka program Q# (.qs) atau OpenQASM (.qasm) di VS Code dan jalankan berkas.

Misalnya, ikuti langkah-langkah ini untuk menjalankan salah satu program sampel Q# yang disertakan QDK dengan ekstensi:

  1. Di VS Code, buka menu File dan pilih File Teks Baru.
  2. Beri nama file yang diakhiri dengan ekstensi .qs.
  3. Dalam file kosong, masukkan sampel. Daftar sampel kode yang disertakan terbuka.
  4. Pilih sampel kode, misalnya sampel Bell Pair.
  5. Untuk menjalankan program di simulator sparse, pilih perintah Jalankan dari CodeLens di atas operasi Main.

Terminal VS Code menunjukkan output dari simulasi.

Note

Anda dapat menambahkan model kebisingan terbatas ke simulasi jarang program Q# dalam QDK ekstensi. Untuk informasi selengkapnya, lihat Menambahkan noise Pauli ke simulator sparse di VS Code.

Jalankan simulasi menggunakan QDKPython paket

Paket ini QDKPython menawarkan keempat simulator. Cara memanggil simulator tergantung pada simulator dan kerangka kerja pemrograman kuantum.

Memanggil simulator pemrosesan jarang

Anda dapat memanggil simulator sparse untuk program Q#, OpenQASM, dan Qiskit. Tabel berikut menunjukkan cara memanggil simulator jarang dari qdk paket untuk 10 bidikan dalam setiap kerangka kerja pemrograman kuantum yang didukung.

Kerangka kerja pemrograman Python API Contoh panggilan
Q# qsharp.run qsharp.run("MyQsharpProgram()", shots=10)
OpenQASM openqasm.run openqasm.run(my_qasm_program, shots=10)
Qiskit qiskit.QSharpBackend QSharpBackend().run(my_qiskit_program, shots=10)

Note

Anda dapat menambahkan model kebisingan ke simulator sparse dengan parameter noise untuk program Q# dan OpenQASM, tetapi tidak dapat menambahkan model kebisingan untuk program Qiskit.

Misalnya, ikuti langkah-langkah ini untuk menjalankan program Bell pair Q# di Jupyter notebook di VS Code:

  1. Di VS Code, buka menu Tampilan dan pilih Palet Perintah.

  2. Masukkan Buat: Baru Jupyter Notebook. File buku catatan kosong terbuka di tab baru.

  3. Di sel pertama, impor qsharp modul dari qdk paket.

    from qdk import qsharp

  4. Di sel baru, gunakan %%qsharp perintah ajaib untuk menulis kode Q#.

    %%qsharp

operation Main() : (Result, Result) {
    use (q1, q2) = (Qubit(), Qubit());
    PrepareBellPair(q1, q2);
    (MResetZ(q1), MResetZ(q2))
}

operation PrepareBellPair(q1 : Qubit, q2 : Qubit) : Unit {
    H(q1);
    CNOT(q1, q2);
}

  5. Membuat sel baru. Untuk menjalankan program Q# pada simulator sparse, panggil fungsi run dari modul qsharp dan tentukan jumlah shot.

    qsharp.run("Main()", shots=10)

Panggil simulator Clifford

Anda dapat memanggil simulator Clifford untuk program Q#, OpenQASM, Qiskit, dan QIR. Tabel berikut menunjukkan cara memanggil simulator Clifford dari qdk paket untuk 10 bidikan dalam setiap kerangka kerja pemrograman kuantum yang didukung.

Kerangka kerja pemrograman Python API Contoh panggilan
Q# qsharp.run qsharp.run("MyQsharpProgram()", type='clifford', shots=10)
OpenQASM openqasm.run openqasm.run(my_qasm_program, type='clifford', shots=10)
Qiskit simulation.NeutralAtomBackend simulation.NeutralAtomBackend().run(my_qiskit_program, simulator_type='clifford', shots=10)
QIR simulation.NeutralAtomDevice simulation.NeutralAtomDevice().simulate(my_qir, type='clifford', shots=10)
QIR simulation.run_qir simulation.run_qir(my_qir, type='clifford', shots=10)

Note

NeutralAtomDevice API dan NeutralAtomBackend adalah untuk simulasi pada komputer kuantum atom netral secara khusus. Untuk informasi selengkapnya, lihat Gambaran umum simulator perangkat atom netral.

Misalnya, kode Python berikut membuat program OpenQASM sederhana dan menjalankan program pada simulator Clifford:

from qdk.openqasm import run

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

run(qasm_code, type='clifford', shots=10)

Memanggil simulator GPU dan CPU

Anda dapat memanggil simulator GPU dan CPU untuk program Qiskit dan QIR. Tabel berikut menunjukkan cara memanggil simulator GPU dari qdk paket untuk 10 bidikan di setiap kerangka kerja pemrograman kuantum yang didukung. Untuk memanggil simulator CPU, ganti 'gpu' dengan 'cpu' untuk parameter jenis simulator.

Kerangka kerja pemrograman Python API Contoh panggilan
Qiskit simulation.NeutralAtomBackend simulation.NeutralAtomBackend().run(my_qiskit_program, simulator_type='gpu', shots=10)
QIR simulation.NeutralAtomDevice simulation.NeutralAtomDevice().simulate(my_qir, type='gpu', shots=10)
QIR simulation.run_qir simulation.run_qir(my_qir, type='gpu', shots=10)

Misalnya, kode Python berikut mengonversi program OpenQASM sederhana ke QIR dan menjalankan QIR pada simulator GPU:

from qdk.openqasm import compile#, ProgramType
from qdk.simulation import run_qir

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

qir = compile(qasm_code)
run_qir(qir, type='gpu', shots=10)
  • Last updated on