Tulis program Qiskit Serverless pertamamu

Versi paket

Kode di halaman ini dikembangkan menggunakan persyaratan berikut. Kami sarankan memakai versi ini atau yang lebih baru.

qiskit[all]~=1.3.1
qiskit-ibm-runtime~=0.34.0
qiskit-aer~=0.15.1
qiskit-serverless~=0.18.1
qiskit-ibm-catalog~=0.2
qiskit-addon-sqd~=0.8.1
qiskit-addon-utils~=0.1.0
qiskit-addon-mpf~=0.2.0
qiskit-addon-aqc-tensor~=0.1.2
qiskit-addon-obp~=0.1.0
scipy~=1.15.0
pyscf~=2.8.0

tips

Qiskit Serverless sedang ditingkatkan, dan fiturnya berubah dengan cepat. Selama fase pengembangan ini, temukan catatan rilis dan dokumentasi terbaru di halaman GitHub Qiskit Serverless.

Contoh ini menunjukkan cara menggunakan alat qiskit-serverless untuk membuat program transpilasi paralel, lalu mengimplementasikan qiskit-ibm-catalog untuk mengunggah programmu ke IBM Quantum Platform agar bisa digunakan sebagai layanan remote yang bisa dipakai ulang.

Ringkasan alur kerja

1. Buat direktori lokal dan file program kosong (./source_files/transpile_remote.py)
2. Tambahkan kode ke programmu yang, saat diunggah ke Qiskit Serverless, akan mentranspilasi sebuah circuit
3. Gunakan qiskit-ibm-catalog untuk autentikasi ke Qiskit Serverless
4. Unggah program ke Qiskit Serverless

Setelah mengunggah programmu, kamu bisa menjalankannya untuk mentranspilasi circuit dengan mengikuti panduan Jalankan workload Qiskit Serverless pertamamu secara remote.

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

Contoh: transpilasi remote dengan Qiskit Serverless

Contoh ini memandumu membuat dan menambahkan ke sebuah file program yang, saat kamu unggah ke Qiskit Serverless, akan mentranspilasi sebuah circuit terhadap backend dan optimization_level target yang diberikan.

tips

Qiskit Serverless mengharuskan pengaturan file .py workload-mu ke dalam direktori tersendiri. Struktur berikut adalah contoh praktik yang baik:

serverless_program
├── program_uploader.ipynb
└── source_files
├── transpile_remote.py
└── *.py

Serverless mengunggah isi direktori tertentu (dalam contoh ini, direktori source_files) untuk dijalankan secara remote. Setelah semuanya siap, kamu bisa menyesuaikan transpile_remote.py untuk mengambil input dan mengembalikan output.

Buat direktori dan file program kosong

Pertama, buat direktori bernama source_files, lalu buat file program di dalam direktori tersebut, sehingga path-nya adalah ./source_files/transpile_remote.py. Ini adalah file yang akan kamu unggah ke Qiskit Serverless.

Tambahkan kode ke file program-mu

Isi file program-mu dengan kode berikut, lalu simpan.

perhatian

Jika kamu membaca cell kode secara lokal di sebuah notebook, kamu akan melihat magic command %%writefile. Menjalankan cell dengan magic command ini menyimpannya ke disk, bukan menjalankannya.

# This cell is hidden from users, it creates a new folder
from pathlib import Path

Path("./source_files").mkdir(exist_ok=True)

%%writefile ./source_files/transpile_remote.py
# If you include the preceding `%%writefile` command (visible only when you read this
# locally in a notebook), running this cell saves to disk rather than executing the code.

from qiskit.transpiler import generate_preset_pass_manager

def transpile_remote(circuit, optimization_level, backend):
    """Transpiles an abstract circuit into an ISA circuit for a given backend."""
    pass_manager = generate_preset_pass_manager(
        optimization_level=optimization_level,
		backend=backend
    )
    isa_circuit = pass_manager.run(circuit)
    return isa_circuit

Tambahkan kode untuk mengambil argumen program

Sekarang tambahkan kode berikut ke file program-mu, yang menyiapkan argumen program.

transpile_remote.py awalmu punya tiga input: circuits, backend_name, dan optimization_level. Serverless saat ini hanya bisa menerima input dan output yang bisa diserialisasi. Karena itu, kamu tidak bisa langsung memasukkan backend, jadi gunakan backend_name sebagai string.

%%writefile --append ./source_files/transpile_remote.py
# If you include the preceding `%%writefile` command (visible only when you read this
# locally in a notebook), running this cell saves to disk rather than executing the code.

from qiskit_serverless import get_arguments, save_result, distribute_task, get

# Get program arguments
arguments = get_arguments()
circuits = arguments.get("circuits")
backend_name = arguments.get("backend_name")
optimization_level = arguments.get("optimization_level")

Tambahkan kode yang memanggil backend

Tambahkan kode berikut ke file program-mu, yang memanggil backend-mu dengan QiskitRuntimeService.

Kode berikut mengasumsikan kamu sudah mengikuti proses untuk menyimpan kredensialmu menggunakan QiskitRuntimeService.save_account, dan akan memuat akun tersimpan default-mu kecuali kamu menentukan lain. Lihat Simpan kredensial login-mu dan Inisialisasi akun layanan Qiskit Runtime-mu untuk informasi lebih lanjut.

%%writefile --append ./source_files/transpile_remote.py
# If you include the preceding `%%writefile` command (visible only when you read this
# locally in a notebook), running this cell saves to disk rather than executing the code.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
backend = service.backend(backend_name)

Tambahkan kode untuk mentranspilasi

Terakhir, tambahkan kode berikut ke file program-mu. Kode ini menjalankan transpile_remote() untuk semua circuits yang dimasukkan, dan mengembalikan transpiled_circuits sebagai hasilnya:

%%writefile --append ./source_files/transpile_remote.py
# If you include the preceding `%%writefile` command (visible only when you read this
# locally in a notebook), running this cell saves to disk rather than executing the code.

# Each circuit is being transpiled and will populate the array
results = [
    transpile_remote(circuit, 1, backend)
    for circuit in circuits
]

save_result({
    "transpiled_circuits": results
})

Autentikasi ke Qiskit Serverless

Gunakan qiskit-ibm-catalog untuk autentikasi ke QiskitServerless dengan API key-mu (kamu bisa memakai API key QiskitRuntimeService-mu, atau membuat API key baru di dashboard IBM Quantum Platform).

from qiskit_ibm_catalog import QiskitServerless, QiskitFunction

# Authenticate to the remote cluster and submit the pattern for remote execution
serverless = QiskitServerless()

Jalankan kode untuk mengunggah

Jalankan kode berikut untuk mengunggah program. Qiskit Serverless mengompres isi working_dir (dalam hal ini, source_files) menjadi sebuah tar, yang diunggah lalu dibersihkan. entrypoint mengidentifikasi file program utama yang akan dijalankan oleh Qiskit Serverless.

transpile_remote_demo = QiskitFunction(
    title="transpile_remote_serverless",
    entrypoint="transpile_remote.py",
    working_dir="./source_files/",
)

serverless.upload(transpile_remote_demo)

QiskitFunction(transpile_remote_serverless)

Verifikasi unggahan

Untuk mengecek apakah berhasil diunggah, gunakan serverless.list(), seperti pada kode berikut:

# Get program from serverless.list() that matches the title of the one we uploaded
next(
    program
    for program in serverless.list()
    if program.title == "transpile_remote_serverless"
)

QiskitFunction(transpile_remote_serverless)

# This cell is hidden from users, it checks the program uploaded correctly
assert _.title == "transpile_remote_serverless"  # noqa: F821

# This cell is hidden from users, it checks the program executes correctly
from time import sleep
from qiskit import QuantumCircuit

qc = QuantumCircuit(2)
transpile_remote_serverless = serverless.load("transpile_remote_serverless")
job = transpile_remote_serverless.run(
    circuits=[qc],
    backend="ibm_sherbrooke",
    optimization_level=1,
)
while True:
    sleep(5)
    status = job.status()
    if status not in ["QUEUED", "INITIALIZING", "RUNNING", "DONE"]:
        raise Exception(
            f"Unexpected job status: '{status}'\n"
            + "Here are the logs:\n"
            + job.logs()
        )
    if status == "DONE":
        break

Langkah selanjutnya

Rekomendasi

• Pelajari cara memasukkan input dan menjalankan programmu secara remote di topik Jalankan workload Qiskit Serverless pertamamu secara remote.