Scrie primul tău program Qiskit Serverless

Package versions

Codul de pe această pagină a fost dezvoltat folosind cerințele de mai jos. Recomandăm utilizarea acestor versiuni sau a unora mai noi.

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

sfat

Qiskit Serverless primește o actualizare și funcționalitățile sale se schimbă rapid. În această fază de dezvoltare, găsești notele de lansare și cea mai recentă documentație pe pagina Qiskit Serverless GitHub.

Acest exemplu demonstrează cum să folosești instrumentele qiskit-serverless pentru a crea un program de transpilare paralelă, și apoi să implementezi qiskit-ibm-catalog pentru a încărca programul tău pe IBM Quantum Platform și a-l folosi ca serviciu remote reutilizabil.

Prezentare generală a fluxului de lucru

1. Creează un director local și un fișier de program gol (./source_files/transpile_remote.py)
2. Adaugă cod în programul tău care, odată încărcat în Qiskit Serverless, va transpila un circuit
3. Folosește qiskit-ibm-catalog pentru a te autentifica la Qiskit Serverless
4. Încarcă programul în Qiskit Serverless

După ce ai încărcat programul, îl poți rula pentru a transpila circuitul urmând ghidul Rulează primul tău workload Qiskit Serverless de la distanță.

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

Exemplu: transpilare la distanță cu Qiskit Serverless

Acest exemplu te ghidează prin crearea și completarea unui fișier de program care, odată încărcat în Qiskit Serverless, va transpila un circuit față de un backend dat și un optimization_level țintă.

sfat

Qiskit Serverless necesită organizarea fișierelor .py ale volumului de lucru într-un director dedicat. Următoarea structură este un exemplu de bună practică:

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

Serverless încarcă conținutul unui director specific (în acest exemplu, directorul source_files) pentru a rula de la distanță. După configurarea acestora, poți ajusta transpile_remote.py pentru a prelua intrări și a returna ieșiri.

Creează directorul și un fișier de program gol

Mai întâi, creează un director numit source_files, apoi creează un fișier de program în director, astfel încât calea sa să fie ./source_files/transpile_remote.py. Acesta este fișierul pe care îl vei încărca în Qiskit Serverless.

Adaugă cod în fișierul de program

Completează fișierul de program cu codul următor, apoi salvează-l.

atenție

Dacă citești celulele de cod local într-un notebook, vei vedea comanda magic %%writefile. Executarea celulelor cu această comandă magic le salvează pe disc în loc să le execute.

# 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

Adaugă cod pentru a obține argumentele programului

Acum adaugă codul următor în fișierul de program, care configurează argumentele programului.

Fișierul tău inițial transpile_remote.py are trei intrări: circuits, backend_name și optimization_level. Serverless este în prezent limitat să accepte doar intrări și ieșiri serializabile. Din acest motiv, nu poți transmite backend direct, deci folosește backend_name ca șir de caractere în schimb.

%%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")

Adaugă cod care apelează Backend-ul

Adaugă codul următor în fișierul de program, care apelează Backend-ul cu QiskitRuntimeService.

Codul următor presupune că ai urmat deja procesul de salvare a acreditărilor folosind QiskitRuntimeService.save_account și va încărca contul tău salvat implicit, cu excepția cazului în care specifici altfel. Vezi Salvează acreditările de autentificare și Inițializează contul tău de serviciu Qiskit Runtime pentru mai multe informații.

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

Adaugă cod pentru transpilare

În final, adaugă codul următor în fișierul de program. Acest cod rulează transpile_remote() pentru toate circuits transmise și returnează transpiled_circuits ca rezultat:

%%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
})

Autentifică-te la Qiskit Serverless

Folosește qiskit-ibm-catalog pentru a te autentifica la QiskitServerless cu cheia ta API (poți folosi cheia API a QiskitRuntimeService, sau crea o nouă cheie API pe panoul de control IBM Quantum Platform).

from qiskit_ibm_catalog import QiskitServerless, QiskitFunction

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

Rulează codul pentru încărcare

Rulează codul următor pentru a încărca programul. Qiskit Serverless comprimă conținutul directorului working_dir (în acest caz, source_files) într-un tar, care este încărcat și apoi curățat. entrypoint identifică fișierul executabil principal al programului pe care Qiskit Serverless îl va rula.

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)

Verifică încărcarea

Pentru a verifica dacă a fost încărcat cu succes, folosește serverless.list(), ca în codul următor:

# 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

Pașii următori

Recomandări

• Află cum să transmiți intrări și să rulezi programul tău de la distanță în tema Rulează primul tău volum de lucru Qiskit Serverless de la distanță.