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.27.0
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

Creează un director local și un fișier de program gol (./source_files/transpile_remote.py)
Adaugă cod în programul tău care, odată încărcat în Qiskit Serverless, va transpila un circuit
Folosește qiskit-ibm-catalog pentru a te autentifica la Qiskit Serverless
Î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-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 obține un serviciu runtime și îl folosește pentru a selecta Backend-ul.

Folosește get_runtime_service în programele Qiskit Serverless

În codul care rulează pe Qiskit Serverless, creează serviciul runtime cu get_runtime_service() (importat din qiskit_serverless) în loc să instanțiezi QiskitRuntimeService() direct.

get_runtime_service() returnează un wrapper direct compatibil în jurul QiskitRuntimeService care înregistrează fiecare job și Session de primitivă IBM Quantum pe care le lansează, în raport cu job-ul Qiskit Serverless părinte. Această legătură este cea care permite platformei să asocieze un job Serverless cu job-urile și Session-urile QPU pe care le generează, pentru urmărirea stării, jurnale și pentru utilizare și contabilizare. Un QiskitRuntimeService simplu trimite job-uri pe care platforma nu le asociază niciodată cu job-ul tău Serverless, astfel încât această legătură se pierde.

Toate argumentele sunt opționale. În codul sursă al programului, forma recomandată este get_runtime_service() fără argumente, care preia datele tale de autentificare din mediu. Acceptă aceleași argumente opționale channel, token, instance și url ca 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 IBM Quantum Compute Service 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_serverless import get_runtime_service

service = get_runtime_service()
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ță.

Prezentare generală a fluxului de lucru​

Exemplu: transpilare la distanță cu Qiskit Serverless​

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

Adaugă cod în fișierul de program​

Adaugă cod pentru a obține argumentele programului​

Adaugă cod care apelează Backend-ul​

Adaugă cod pentru transpilare​

Autentifică-te la Qiskit Serverless​

Rulează codul pentru încărcare​

Verifică încărcarea​

Pașii următori​