Scrivi il tuo primo programma Qiskit Serverless

Versioni del pacchetto

Il codice di questa pagina è stato sviluppato in base ai seguenti requisiti. Si consiglia di utilizzare 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.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

Tip

Qiskit Serverless sta subendo un aggiornamento e le sue caratteristiche stanno cambiando rapidamente. Durante questa fase di sviluppo, è possibile trovare le note di rilascio e la documentazione più recente alla pagina Qiskit ServerlessGitHub.

Questo esempio illustra come utilizzare qiskit-serverless gli strumenti per creare un programma di transpilazione parallela e, successivamente, come implementarlo qiskit-ibm-catalog per caricare il programma su IBM Quantum Platform e utilizzarlo come servizio remoto riutilizzabile.

Panoramica del flusso di lavoro

Crea una cartella locale e svuota il file di programma (./source_files/transpile_remote.py)
Aggiungi al tuo programma del codice che, una volta caricato su Qiskit Serverless, traspili un circuito
Utilizza qiskit-ibm-catalog per autenticarti su Qiskit Serverless
Carica il programma su Qiskit Serverless

Dopo aver caricato il programma, puoi eseguirlo per traspilare il circuito seguendo la guida "Esegui in remoto il tuo primo carico di lavoro Qiskit Serverless ".

Esempio: transpilazione remota con Qiskit Serverless

Questo esempio illustra come creare e modificare un file di programma che, una volta caricato su Qiskit Serverless, compilerà un circuit in base a un dato backend e a una destinazione optimization_level.

Tip

Qiskit Serverless richiede l'impostazione dei file .py del carico di lavoro in una directory dedicata. La struttura seguente è un esempio di buona prassi:

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

Serverless carica i contenuti di una directory specifica (in questo esempio, la source_files directory) per eseguirli in remoto. Una volta configurati, è possibile regolarli transpile_remote.py per acquisire gli input e restituire gli output.

Crea la cartella e un file di programma vuoto

Per prima cosa, crea una cartella denominata source_files, quindi crea un file di programma all'interno della cartella, in modo che il suo percorso sia ./source_files/transpile_remote.py. Questo è il file che dovrai caricare su Qiskit Serverless.

Aggiungi il codice al tuo file di programma

Inserisci il codice seguente nel file del programma, quindi salvalo.

Caution

Se stai leggendo le celle di codice localmente in un notebook, vedrai il comando %%writefile magico. L'esecuzione delle celle con questo comando speciale le salva su disco invece di eseguirle.

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

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

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

Aggiungi il codice per recuperare gli argomenti del programma

Ora aggiungi il seguente codice al tuo file di programma, che imposta gli argomenti del programma.

Il vostro transpile_remote.py iniziale ha tre ingressi: circuits, backend_name, e optimization_level. Serverless è attualmente limitato ad accettare solo ingressi e uscite serializzabili. Per questo motivo, non è possibile inserire direttamente backend , ma è necessario utilizzare backend_name come stringa.

./source_files/transpile_remote.py (appended)

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

Aggiungi il codice che richiama il backend

Aggiungi il seguente codice al tuo file di programma: questo codice recupera un servizio di runtime e lo utilizza per selezionare il tuo backend.

Utilizzare la funzione `get_runtime_service` all'interno dei programmi ` Qiskit Serverless `

Nel codice eseguito su Qiskit Serverless, crea il tuo servizio di runtime utilizzando get_runtime_service() (importato da qiskit_serverless) invece di istanziare direttamente QiskitRuntimeService() .

get_runtime_service() restituisce un wrapper "drop-in" QiskitRuntimeService che registra ogni lavoro primitivo e ogni sessione di IBM Quantum che avvia in relazione al lavoro principale di Qiskit Serverless. È proprio questo collegamento che consente alla piattaforma di associare un’attività serverless alle attività e alle sessioni della QPU da essa generate, a fini di monitoraggio dello stato, registrazione dei log, utilizzo e contabilità. Un "bare" invia QiskitRuntimeService operazioni che la piattaforma non associa mai alla tua operazione serverless, per cui tale collegamento va perso.

Tutti gli argomenti sono facoltativi. Nel codice sorgente del programma, la sintassi consigliata è get_runtime_service() quella senza argomenti, che recupera i dati di autenticazione dall'ambiente. Accetta gli stessi argomenti url opzionali channel, token, instance, e di QiskitRuntimeService.

Il codice riportato di seguito presuppone che tu abbia già completato la procedura per salvare le tue credenziali utilizzando QiskitRuntimeService.save_account, e caricherà l'account predefinito salvato, a meno che tu non specifichi diversamente. Per ulteriori informazioni, consulta le sezioni “Salva le credenziali di accesso” e “Inizializza il tuo account IBM Quantum Compute Service ”.

./source_files/transpile_remote.py (appended)

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

Aggiungi codice per la transpilazione

Infine, aggiungi il seguente codice al tuo file di programma. Questo codice esegue transpile_remote() l'operazione su tutti i valori circuits passati in parametro e restituisce il transpiled_circuits risultato:

./source_files/transpile_remote.py (appended)

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

Effettua l'autenticazione su Qiskit Serverless

Utilizza qiskit-ibm-catalog per effettuare l'autenticazione su QiskitServerless con la tua chiave API (puoi utilizzare la tua chiave QiskitRuntimeService API oppure crearne una nuova nella dashboard di IBM Quantum Platform ).

from qiskit_ibm_catalog import QiskitServerless, QiskitFunction

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

Esegui il codice per caricare

Esegui il codice seguente per caricare il programma. Qiskit Serverless comprime il contenuto di working_dir (in questo caso, source_files) in un file tar, che viene caricato e successivamente eliminato. Il file entrypoint identifica il programma eseguibile principale che consente il funzionamento di Qiskit Serverless.

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

serverless.upload(transpile_remote_demo)

Output:

QiskitFunction(transpile_remote_serverless)

Verifica il caricamento

Per verificare se il caricamento è andato a buon fine, usa serverless.list(), come nel codice seguente:

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

Output:

QiskitFunction(transpile_remote_serverless)

Passi successivi

Suggerimenti

Scopri come passare parametri e eseguire il tuo programma in remoto nell'argomento " Esegui in remoto il tuo primo carico di lavoro Qiskit Serverless ".

Questa pagina è stata utile?

Segnala un bug, un errore di battitura o richiedi contenuti su GitHub.