Écrire ton premier programme Qiskit Serverless

Versions des paquets

Le code de cette page a été développé en utilisant les exigences suivantes. Nous recommandons d'utiliser ces versions ou des versions plus récentes.

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

conseil

Qiskit Serverless bénéficie d'une mise à niveau, et ses fonctionnalités évoluent rapidement. Pendant cette phase de développement, retrouve les notes de version et la documentation la plus récente sur la page Qiskit Serverless GitHub.

Cet exemple montre comment utiliser les outils qiskit-serverless pour créer un programme de transpilation parallèle, puis utiliser qiskit-ibm-catalog pour téléverser ton programme sur IBM Quantum Platform et l'utiliser comme service distant réutilisable.

Vue d'ensemble du workflow

1. Créer un répertoire local et un fichier de programme vide (./source_files/transpile_remote.py)

2. Ajouter du code à ton programme qui, une fois téléversé dans Qiskit Serverless, transpilera un circuit

3. Utiliser qiskit-ibm-catalog pour s'authentifier à Qiskit Serverless

4. Téléverser le programme dans Qiskit Serverless

Après avoir téléversé ton programme, tu pourras l'exécuter pour transpiler le circuit en suivant le guide Exécuter ta première charge de travail Qiskit Serverless à distance.

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"qiskit": "qiskit", "qiskit_ibm_catalog": "qiskit-ibm-catalog", "qiskit_serverless": "qiskit-serverless"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

Exemple : Transpilation à distance avec Qiskit Serverless

Cet exemple te guide dans la création et l'ajout de code à un fichier de programme qui, une fois téléversé dans Qiskit Serverless, transpilera un circuit par rapport à un backend donné et un optimization_level cible.

conseil

Qiskit Serverless nécessite de configurer les fichiers .py de ta charge de travail dans un répertoire dédié. La structure suivante est un exemple de bonne pratique :

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

Serverless téléverse le contenu d'un répertoire spécifique (dans cet exemple, le répertoire source_files) pour l'exécuter à distance. Une fois ces fichiers configurés, tu peux ajuster transpile_remote.py pour récupérer les entrées et retourner les sorties.

Créer le répertoire et un fichier de programme vide

D'abord, crée un répertoire nommé source_files, puis crée un fichier de programme dans ce répertoire, de sorte que son chemin soit ./source_files/transpile_remote.py. C'est le fichier que tu téléverseras dans Qiskit Serverless.

Ajouter du code à ton fichier de programme

Remplis ton fichier de programme avec le code suivant, puis enregistre-le.

attention

Si tu lis les cellules de code localement dans un notebook, tu verras la commande magique %%writefile. Exécuter des cellules avec cette commande magique les enregistre sur le disque plutôt que de les exécuter.

# 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

Ajouter du code pour récupérer les arguments du programme

Maintenant, ajoute le code suivant à ton fichier de programme, qui configure les arguments du programme.

Ton fichier transpile_remote.py initial a trois entrées : circuits, backend_name et optimization_level. Serverless est actuellement limité à n'accepter que des entrées et sorties sérialisables. Pour cette raison, tu ne peux pas passer backend directement, alors utilise backend_name comme chaîne de caractères à la place.

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

Ajouter du code qui appelle le backend

Ajoute le code suivant à ton fichier de programme, qui obtient un service d'exécution et l'utilise pour sélectionner ton backend.

Utilise get_runtime_service à l'intérieur des programmes Qiskit Serverless

Dans le code qui s'exécute sur Qiskit Serverless, crée ton service d'exécution avec get_runtime_service() (importé depuis qiskit_serverless) au lieu d'instancier directement QiskitRuntimeService().

get_runtime_service() retourne un wrapper directement substituable à QiskitRuntimeService qui enregistre chaque job et session de primitive IBM Quantum qu'il lance par rapport au job Qiskit Serverless parent. Ce lien est ce qui permet à la plateforme de relier un job Serverless aux jobs et sessions QPU qu'il génère, pour le suivi du statut, les journaux, ainsi que l'utilisation et la facturation. Un QiskitRuntimeService nu soumet des jobs que la plateforme n'associe jamais à ton job Serverless, donc ce lien est perdu.

Tous les arguments sont facultatifs. Dans le code source du programme, la forme recommandée est get_runtime_service() sans arguments, qui récupère tes données d'authentification depuis l'environnement. Elle accepte les mêmes arguments facultatifs channel, token, instance et url que QiskitRuntimeService.

Le code suivant suppose que tu as déjà suivi le processus pour enregistrer tes identifiants en utilisant QiskitRuntimeService.save_account, et chargera ton compte par défaut enregistré sauf indication contraire. Consulte Enregistrer tes identifiants de connexion et Initialiser ton compte IBM Quantum Compute Service pour plus d'informations.

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

Ajouter du code pour transpiler

Enfin, ajoute le code suivant à ton fichier de programme. Ce code exécute transpile_remote() sur tous les circuits passés en entrée, et retourne les transpiled_circuits comme résultat :

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

S'authentifier à Qiskit Serverless

Utilise qiskit-ibm-catalog pour t'authentifier à QiskitServerless avec ta clé API (tu peux utiliser ta clé API QiskitRuntimeService ou en créer une nouvelle sur le tableau de bord IBM Quantum Platform).

from qiskit_ibm_catalog import QiskitServerless, QiskitFunction

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

Exécuter le code pour téléverser

Exécute le code suivant pour téléverser le programme. Qiskit Serverless compresse le contenu de working_dir (dans ce cas, source_files) en un fichier tar, qui est téléversé puis nettoyé. Le entrypoint identifie le programme principal exécutable que Qiskit Serverless doit lancer.

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)

Vérifier le téléversement

Pour vérifier si le téléversement a réussi, utilise serverless.list(), comme dans le code suivant :

# 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

Étapes suivantes

Recommandations

• Apprends à passer des entrées et à exécuter ton programme à distance dans le sujet Exécuter ta première charge de travail Qiskit Serverless à distance.