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

1. Crea una cartella locale e svuota il file di programma (./source_files/transpile_remote.py)
2. Aggiungi al tuo programma del codice che, una volta caricato su Qiskit Serverless, traspili un circuito
3. Utilizza qiskit-ibm-catalog per autenticarti su Qiskit Serverless
4. 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.

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.

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

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

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

# 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, che richiama il tuo backend con 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 ”.

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

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:

# 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