Vai al contenuto principale

Scrivi il tuo primo programma Qiskit Serverless

Versioni dei pacchetti

Il codice in questa pagina è stato sviluppato utilizzando i seguenti requisiti. Si consiglia di usare queste versioni o versioni più recenti.

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

Questo esempio mostra come usare gli strumenti di qiskit-serverless per creare un programma di transpilazione parallela, e come poi utilizzare qiskit-ibm-catalog per distribuire il tuo programma su IBM Quantum Platform e usarlo come servizio remoto riutilizzabile.

Esempio: transpilazione remota con Qiskit Serverless​

Inizia con il seguente esempio che transpila un circuit su un determinato backend e con un optimization_level target, e aggiungi gradualmente altri elementi per distribuire il tuo workload su Qiskit Serverless.

Metti il seguente blocco di codice nel file ./source_files/transpile_remote.py. Questo file è il programma da caricare su Qiskit Serverless.

# Added by doQumentation — required packages for this notebook
!pip install -q qiskit qiskit-ibm-catalog qiskit-ibm-runtime qiskit-serverless
# This cell is hidden from users, it just creates a new folder
from pathlib import Path

Path("./source_files").mkdir(exist_ok=True)
%%writefile ./source_files/transpile_remote.py

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
Writing ./source_files/transpile_remote.py

Configura i file​

Qiskit Serverless richiede che i file .py del tuo workload siano organizzati in una directory dedicata. La struttura seguente è un esempio di buona pratica:

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

Serverless carica i contenuti di source_files per eseguirli in remoto. Una volta configurati, puoi modificare transpile_remote.py per recuperare gli input e restituire gli output.

Ottieni gli argomenti del programma​

Il tuo transpile_remote.py iniziale ha tre input: circuits, backend_name e optimization_level. Serverless al momento accetta solo input e output serializzabili. Per questo motivo non puoi passare backend direttamente, quindi usa backend_name come stringa.

%%writefile --append ./source_files/transpile_remote.py

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")
Appending to ./source_files/transpile_remote.py

A questo punto, puoi ottenere il tuo backend con QiskitRuntimeService e aggiungere il tuo programma esistente con il codice seguente. Il codice richiede che tu abbia già salvato le tue credenziali.

%%writefile --append ./source_files/transpile_remote.py

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
backend = service.backend(backend_name)
Appending to ./source_files/transpile_remote.py

Infine, puoi eseguire transpile_remote() su tutti i circuits passati e restituire i transpiled_circuits come risultato:

%%writefile --append ./source_files/transpile_remote.py

results = [
    transpile_remote(circuit, 1, backend)
    for circuit in circuits
]

save_result({
    "transpiled_circuits": results
})
Appending to ./source_files/transpile_remote.py

Distribuisci su IBM Quantum Platform​

La sezione precedente ha creato un programma da eseguire in remoto. I blocchi di codice in questa sezione caricano quel programma su Qiskit Serverless.

Usa qiskit-ibm-catalog per autenticarti su QiskitServerless con la tua chiave API, che puoi trovare sul pannello IBM Quantum, e carica il programma.

Puoi usare save_account() per salvare le tue credenziali (vedi la sezione Configura per usare IBM Cloud). Tieni presente che questo sovrascrive le credenziali nello stesso file usato da QiskitRuntimeService.save_account().

from qiskit_ibm_catalog import QiskitServerless, QiskitFunction

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

Qiskit Serverless comprime i contenuti di working_dir (in questo caso, source_files) in un archivio tar, che viene caricato e rimosso al termine. L'entrypoint identifica il file eseguibile principale che Qiskit Serverless deve eseguire. Inoltre, se il tuo programma ha dipendenze pip personalizzate, puoi aggiungerle a un array dependencies:

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)

Per verificare che il caricamento sia andato a buon fine, usa serverless.list():

# 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

Passi successivi​

Raccomandazioni