Écrire ton premier programme Qiskit Serverless

Package versions

Le code de cette page a été développé avec les dépendances 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.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

conseil

Qiskit Serverless est en cours de mise à niveau et ses fonctionnalités évoluent rapidement. Pendant cette phase de développement, consulte les notes de version et la documentation la plus récente sur la page GitHub de Qiskit Serverless.

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 — required packages for this notebook
!pip install -q qiskit qiskit-ibm-catalog qiskit-ibm-runtime qiskit-serverless

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 appelle ton backend avec 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 de service Qiskit Runtime 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_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
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.