Bina dan jalankan program kuantum pertama anda

Pengenalan

Dalam video berikut, Olivia Lanes akan membawa anda melalui kandungan dalam pelajaran ini. Sebagai alternatif, anda boleh buka video YouTube untuk pelajaran ini dalam tetingkap berasingan.

Selamat datang ke Guna komputer kuantum hari ini! Matlamat kursus ini adalah untuk anda menjalankan kod pada komputer kuantum sebenar dalam masa sesingkat mungkin, tanpa memerlukan latar belakang sebelumnya. Jom kita mulakan.

Pelajaran pertama ini adalah pengenalan praktikal yang lembut kepada pengkomputeran kuantum yang sesuai untuk pemula yang ingin tahu mahupun pemimpin yang sibuk. Anda akan belajar tentang Circuit kuantum dan menulis program kuantum kecil yang mencipta jalinan (entanglement), serta menjalankannya pada komputer kuantum IBM® yang sebenar. Anda juga boleh memilih untuk menjalankan program yang sama pada simulator, sekiranya anda ingin melangkau penggunaan komputer kuantum sebenar.

Anda boleh jalankan notebook ini dari atas ke bawah dalam runtime Google Colab yang baru, atau jalankan secara tempatan.

Persediaan

Untuk menjalankan notebook ini dalam Google Colab, anda perlukan akaun Google supaya anda boleh membuka notebook dan melaksanakan sel dalam pelayar.

Untuk menjalankan pada komputer kuantum IBM yang sebenar, anda juga perlukan (percuma) akaun IBM Quantum® Platform. Anda boleh buka instance menggunakan Open Plan untuk mendapat 10 minit masa unit pemproses kuantum (QPU) setiap tetingkap bergolek 28 hari, yang sebenarnya agak banyak! Jika anda menghadapi masalah dengan akaun anda, lihat halaman Sokongan.

Anda juga boleh menjalankan notebook ini secara tempatan selepas memasang Qiskit dengan mengikut arahan di IBM Quantum Platform.

Pemasangan dan import

Dalam Colab, kita pasang kebergantungan di dalam notebook supaya semua orang menggunakan alat yang sama. Sel seterusnya memasang Qiskit dengan modul visualisasi serta dua tambahan: Aer (simulator pantas) dan klien IBM Runtime (untuk menjalankan pada komputer kuantum).

Seterusnya, kita ada beberapa import. Kelas QuantumCircuit adalah tempat kita takrifkan bit kuantum, atau Qubit, dan takrifkan operasi pada Qubit tersebut. Ini adalah istilah kuantum pertama kita: Qubit adalah blok binaan asas pengkomputeran kuantum, sama seperti bit adalah blok binaan pengkomputeran klasik. Kita akan belajar lebih lanjut tentang sifat-sifat istimewa Qubit semasa kita membina Circuit. Seterusnya, plot_histogram akan digunakan untuk memvisualisasikan keputusan Circuit kuantum kita. AerSimulator membolehkan kita mensimulasikan Circuit kuantum pada komputer klasik. Tetapi simulator tidak boleh menjalankan Circuit kuantum pada skala yang sama seperti komputer kuantum sebenar; itulah sebabnya kita memerlukan komputer kuantum sebenar. Ini boleh berguna untuk ujian, penyahpepijatan, atau tujuan pendidikan; atau jika anda telah menghabiskan 10 minit percuma masa QPU anda. preset_passmanagers membantu mengoptimumkan Circuit untuk dijalankan dengan cekap pada perkakasan, yang menjadi sangat penting apabila Circuit kita semakin kompleks. Sampler dan QiskitRuntimeService diperlukan untuk benar-benar menjalankan Circuit pada komputer kuantum. Lebih lanjut tentang ini nanti.

# Added by doQumentation — required packages for this notebook
!pip install -q qiskit

!pip install 'qiskit[visualization]' qiskit-ibm-runtime qiskit-aer
# Core Qiskit imports
from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from qiskit_aer import AerSimulator
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

# IBM Runtime specific imports
from qiskit_ibm_runtime import SamplerV2 as Sampler, QiskitRuntimeService

Seterusnya kita akan buat semakan persekitaran yang cepat. Kita sahkan versi dan sahkan import.

Jika ada yang gagal di sini, biasanya ia adalah masalah pemasangan kebergantungan; membetulkannya sekarang mencegah ralat yang mengelirukan kemudian.

import sys

import qiskit
import qiskit_aer
import qiskit_ibm_runtime

print("Python:", sys.version.split()[0])
print("qiskit:", qiskit.__version__)
print("qiskit-aer:", qiskit_aer.__version__)
print("qiskit-ibm-runtime:", qiskit_ibm_runtime.__version__)

Python: 3.12.2
qiskit: 2.2.3
qiskit-aer: 0.17.2
qiskit-ibm-runtime: 0.41.1

Sedikit pengembaraan sampingan: guna Composer

Sebelum kita menulis kod, adalah berguna untuk melihat Circuit secara visual. IBM Quantum Composer membolehkan anda membina Circuit dengan menyeret Gate ke atas wayar. Ini adalah cara yang bagus untuk belajar apa yang dilakukan oleh Circuit tanpa terganggu oleh sintaks.

Buka Composer di sini.

Setelah ia dimuatkan, lancarkan tutorial berpandu dari menu: Help | Build your first circuit. Kerjakanlah mengikut kadar anda sendiri. Semasa anda maju, perhatikan bagaimana setiap Gate mengubah apa yang anda jangka untuk diukur.

Tutorial tersebut membimbing anda membina Circuit "Hello World". Ia divisualisasikan dalam apa yang dipanggil diagram Circuit, di mana Qubit diwakili oleh garisan mendatar dan Gate yang bertindak ke atas Qubit tersebut diwakili oleh kotak atau simbol lain pada garisan tersebut. Circuit ini memperkenalkan kita kepada beberapa ciri utama Qubit dan komputer kuantum:

Pertama, kotak merah berlabel "H" adalah Gate Hadamard, yang mencipta keadaan superposisi Qubit 0. Tidak seperti bit, yang hanya boleh berada dalam keadaan 1 atau 0, keadaan Qubit boleh merangkumi kedua-dua kemungkinan sekaligus, dengan berat tertentu (dipanggil amplitud) yang dilekatkan pada setiap satu. Superposisi tidak bermakna anda akan melihat kedua-dua keputusan dalam satu pengukuran; ia bermakna keadaan itu ditetapkan supaya sama ada hasilnya boleh berlaku apabila anda mengukur.

Kedua, bulatan-bulatan dan garisan menegak yang menyambungkan dua Qubit adalah Gate CNOT, yang menjana jalinan (entanglement) antara dua Qubit. Entanglement adalah sejenis hubungan istimewa antara Qubit. Apabila Qubit berjalinan, hasil pengukuran boleh berkorelasi kuat dengan cara yang tidak sepadan dengan apa yang kita jangkakan daripada lemparan syiling bebas biasa, atau daripada sebarang korelasi klasik. Apabila dua Qubit berjalinan, mengukur satu akan serta-merta memberitahu anda hasil pengukuran yang satu lagi.

Satu lagi idea utama yang akan anda lihat dalam tutorial adalah shots. Oleh kerana pengukuran adalah saat Qubit berhenti berkelakuan seperti keadaan kuantum dan memberikan anda bacaan klasik, keadaan superposisi akan runtuh secara kebarangkalian kepada sama ada 0 atau 1 apabila diukur. Jadi, untuk belajar tentang superposisi itu, anda perlu mengukurnya berkali-kali dengan menjalankan Circuit yang sama untuk mengumpul statistik. Ini dipanggil shots.

Semak kefahaman anda

Fikirkan setiap soalan di bawah, kemudian klik untuk mendedahkan jawapan.

Bolehkah anda melihat superposisi secara langsung daripada satu pengukuran?

Jawapan

Tidak. Satu pengukuran sentiasa mengembalikan nilai klasik: sama ada 0 atau 1. Idea "campuran" hanya muncul dalam statistik yang anda lihat selepas banyak kali dijalankan, juga dipanggil shots.

Dalam bahasa mudah, apakah yang diberikan oleh entanglement kepada anda?

Jawapan

Ia memberikan anda hasil yang terpaut. Mengukur satu Qubit memberitahu anda sesuatu tentang yang satu lagi. Pertautan ini lebih kuat daripada kerawakan bebas dan lebih kuat daripada sebarang korelasi semata-mata klasik atau kerawakan bersama yang boleh dijelaskan.

Jika Qubit berada dalam superposisi, apakah yang anda lihat dalam satu pengukuran, dan mengapa anda memerlukan banyak shots?

Jawapan

Dalam satu pengukuran anda hanya melihat satu keputusan klasik: sama ada 0 atau 1. Anda memerlukan banyak shots kerana "superposisi" muncul sebagai taburan kebarangkalian, yang hanya boleh anda anggarkan dengan mengumpul statistik melalui percubaan berulang.

Lihat histogram pengukuran Circuit Hello World anda dalam Composer. Apakah yang anda lihat? Mengapa ini adalah tanda tangan entanglement?

Jawapan

Ia menunjukkan anda kebarangkalian 50% berada dalam keadaan $|00\rangle$ dan kebarangkalian 50% berada dalam keadaan $|11\rangle$. Ini bermakna jika anda mengukur satu sebagai 0, yang satu lagi akan menjadi 0 dan jika anda mengukur satu sebagai 1, yang satu lagi juga akan menjadi 1. Ini adalah korelasi antara dua Qubit yang boleh dijelaskan oleh entanglement.

Cipta dan jalankan program kuantum menggunakan Qiskit

Okay, kembali kepada pengekodan. Kita akan menjana keadaan berjalinan yang sama seperti yang kita buat dalam Composer (dipanggil keadaan Bell $\Phi^+$ (phi-plus)) tetapi kali ini, kita akan menulis kod secara manual. Kita perlu membina kemahiran ini kerana apabila kita skala kepada lebih banyak Qubit dan Circuit yang lebih rumit, Composer tidak akan dapat membantu kita.

Untuk membina Circuit keadaan Bell, kita gunakan Gate $H$ (Hadamard) untuk meletakkan Qubit pertama ke dalam superposisi yang sama rata. Kemudian kita gunakan Gate $CX$ (controlled-NOT), yang menjalinan dua keadaan bersama. Dua Qubit kini berkorelasi dengan cara yang tiada padanannya secara klasik.

# --- Build the Bell circuit (phi-plus) ---
bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0, 1)
bell.measure_all()  # creates a classical register named "meas"

bell.draw("mpl")

Fungsi pembantu untuk menjalankan Circuit

Sekarang mari kita takrifkan fungsi pembantu yang mengendalikan proses menjalankan Circuit kuantum dan mendapatkan semula keputusan pengukuran. Fungsi ini menguruskan transpilasi Circuit agar sepadan dengan set arahan Backend, menjalankannya melalui primitif Sampler, dan mengekstrak kiraan daripada keputusan.

def run_circuit_and_get_counts(circuit, backend, shots=1000):
    """
    Runs a quantum circuit on a specified backend and returns the measurement counts.

    Args:
        circuit (QuantumCircuit): The quantum circuit to run.
        backend: The Qiskit backend (real device or simulator).
        shots (int): The number of shots to run the circuit.

    Returns:
        dict: A dictionary of measurement counts.
    """
    pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
    isa_circuit = pm.run(circuit)

    sampler = Sampler(mode=backend)

    job = sampler.run([isa_circuit], shots=shots)
    result = job.result()

    return result[0].data.meas.get_counts()

Jalankan pada QPU dan visualisasikan keputusan

Akhirnya, kita jalankan Circuit pada unit pemproses kuantum (QPU) IBM dalam awan untuk 1000 shots dan plot keputusannya. QPU IBM adalah sistem fizikal yang boleh menangkap bunyi, jadi Gate sedikit tidak sempurna, pengukuran kadang-kadang boleh salah, dan kalibrasi peranti berubah dari masa ke masa.

Menjalankan pada komputer kuantum sebenar juga memperkenalkan pertimbangan praktikal. Kerja-kerja boleh beratur, kerana ramai orang mungkin menggunakan peranti yang sama. Anda juga perlu memilih bilangan shots yang mengimbangi pertimbangan statistik (lebih banyak shots bermakna nisbah isyarat-bunyi yang lebih tinggi) dengan kekangan masa/kos.

Ikuti arahan dalam ulasan kod sel seterusnya. Selepas menjalankan sel, anda sepatutnya melihat histogram dengan kiraan yang lebih kurang sama untuk rentetan bit $00$ dan $11$, dengan beberapa kejadian $01$ atau $10$ disebabkan oleh bunyi. Sel berikut dalam notebook ini menjalankan Circuit yang sama pada simulator, sekiranya anda ingin melangkau menjalankan pada QPU.

# Syntax for first saving your token.  Delete these lines after saving your credentials.
QiskitRuntimeService.save_account(
    channel="ibm_quantum_platform",
    token="YOUR_TOKEN_HERE",
    overwrite=True,
    set_as_default=True,
)
service = QiskitRuntimeService(channel="ibm_quantum_platform")

# Load saved credentials
service = QiskitRuntimeService()

# Use the least busy backend, or uncomment the loading of a specific backend like "ibm_fez".
backend = service.least_busy(operational=True, simulator=False, min_num_qubits=127)
# backend = service.backend("ibm_fez")
print(backend.name)

ibm_pittsburgh

counts = run_circuit_and_get_counts(bell, backend, shots=1000)
plot_histogram(counts)

Jalankan pada simulator dan visualisasikan keputusan

Simulator adalah versi "dunia sempurna" pengkomputeran kuantum. Di sini kita jalankan Circuit pada simulator untuk 1000 shots dan plot keputusannya. Anda sepatutnya melihat kiraan yang lebih kurang sama untuk keadaan $00$ dan $11$, tanpa sebarang kejadian $01$ atau $10$, yang merupakan tanda tangan korelasi sempurna keadaan Bell.

backend = AerSimulator()
counts = run_circuit_and_get_counts(bell, backend, shots=1000)

plot_histogram(counts)

Semak kefahaman anda

Apakah dua Gate yang mencipta keadaan Bell di sini?

Jawapan

Gate H pada Qubit 0, diikuti oleh Gate CX dengan Qubit 0 sebagai kawalan dan Qubit 1 sebagai sasaran.

Pada simulator ideal, dua rentetan bit manakah yang sepatutnya mendominasi histogram?

Jawapan

00 dan 11 sepatutnya mendominasi.

Mengapa simulator yang sempurna tidak semestinya mempunyai bilangan kiraan 00 yang tepat sama dengan kiraan 11?

Jawapan

Walaupun simulator adalah "sempurna" dan menghasilkan keadaan Bell yang sempurna, ia masih mensimulasikan proses yang pada dasarnya rawak, jadi turun naik statistik masih akan berlaku. Ia seperti melambung syiling 1000 kali: walaupun terdapat peluang 50-50 yang tepat bagi syiling mendarat pada kepala atau ekor, itu tidak bermakna anda akan selalu mendapat tepat 500 kes kepala dan 500 ekor.

Mengapa komputer kuantum sebenar mungkin menunjukkan beberapa keputusan 01 atau 10 walaupun simulator tidak?

Jawapan

Kerana peranti sebenar mempunyai bunyi. Gate dan pengukuran tidak sempurna, dan itu boleh memperkenalkan ralat yang kadang-kadang berlaku.

Apakah satu perbezaan praktikal antara simulator dan komputer kuantum sebenar selain daripada bunyi?

Jawapan

Komputer kuantum boleh melibatkan masa beratur, ketersediaan terhad, dan kekangan khusus peranti yang mempengaruhi cara Circuit dijalankan.

Kesimpulan

Kita mulakan dengan menyediakan Qiskit dalam persekitaran Colab yang baru, yang merupakan cara tepat bagaimana banyak aliran kerja notebook dunia sebenar bermula. Kita ikutinya dengan perjalanan ke dalam pengkomputeran kuantum menggunakan Composer. Kita kemudiannya membina Circuit dua-Qubit yang mudah yang menghasilkan keadaan Bell $\Phi^+$ dan menggunakan pensampelan berulang serta memvisualisasikan entanglement sebagai korelasi dalam histogram pengukuran Qubit. Kita juga melihat bagaimana komputer kuantum sebenar memperkenalkan bunyi dan ralat.

Objektif pembelajaran

Sekarang setelah kita melalui cara mencipta keadaan Bell $\Phi^+$, cuba lihat sama ada anda boleh mengedit kod untuk mencipta salah satu daripada tiga keadaan Bell yang lain. Khususnya, keadaan $\Psi^-$ akan digunakan dalam pelajaran akan datang, jadi jika anda berjaya menciptanya, anda akan berada di hadapan.