Écrivez votre premier programme Qiskit Serverless

• Versions de package

  Le code de cette page a été développé en tenant compte des 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.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
  

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

Présentation du flux de travail

1. Créer un répertoire local et vider le fichier programme (./source_files/transpile_remote.py)
2. Ajoutez à votre programme du code qui, une fois téléchargé sur Qiskit Serverless, compilera un circuit
3. Utilisez qiskit-ibm-catalog pour vous authentifier sur Qiskit Serverless
4. Téléchargez le programme sur Qiskit Serverless

Une fois votre programme téléchargé, vous pouvez l'exécuter pour transcompiler le circuit en suivant le guide « Exécuter à distance votre première charge de travail Qiskit Serverless ».

Exemple : transpilation à distance avec Qiskit Serverless

Cet exemple vous guide tout au long de la création et de l'enrichissement d'un fichier de programme qui, une fois téléchargé sur Qiskit Serverless, transpilera un circuit en fonction d'un donné backend et d'une cible optimization_level.

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

Serverless télécharge le contenu d'un répertoire spécifique (dans cet exemple, le source_files répertoire) pour l'exécuter à distance. Une fois ces paramètres configurés, vous pouvez les ajuster transpile_remote.py pour récupérer les données d'entrée et renvoyer les données de sortie.

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

Commencez par créer un répertoire nommé source_files, puis créez un fichier programme dans ce répertoire, de sorte que son chemin d'accès soit ./source_files/transpile_remote.py. Voici le fichier que vous devrez télécharger sur Qiskit Serverless.

Ajoutez du code à votre fichier de programme

Insérez le code suivant dans votre fichier de programme, puis enregistrez-le.

# 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

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

Ajoutez maintenant le code suivant à votre fichier de programme; il permet de définir les arguments du programme.

Votre site initial transpile_remote.py comporte trois entrées : circuits, backend_name, et optimization_level. Serverless est actuellement limité à l'acceptation d'entrées et de sorties sérialisables. Pour cette raison, vous ne pouvez pas transmettre directement backend , vous devez donc utiliser backend_name comme chaîne de caractères.

# 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 le code qui appelle le backend

Ajoutez le code suivant à votre fichier de programme, qui appelle votre backend avec QiskitRuntimeService.

Le code suivant part du principe que vous avez déjà suivi la procédure pour enregistrer vos identifiants à l'aide de QiskitRuntimeService.save_account, et chargera votre compte par défaut enregistré, sauf indication contraire de votre part. Pour plus d'informations, consultez les sections « Enregistrer vos identifiants de connexion » et « Initialiser votre compte 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)

Ajouter du code à transcompiler

Pour finir, ajoutez le code suivant à votre fichier de programme. Ce code traite tous transpile_remote() les éléments circuits transmis et renvoie le transpiled_circuits résultat :

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

Se connecter à Qiskit Serverless

Utilisez qiskit-ibm-catalog pour vous connecter à QiskitServerless à l'aide de votre clé API (vous pouvez utiliser votre clé QiskitRuntimeService API actuelle ou en créer une nouvelle sur le tableau de bord de l' 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 effectuer le téléchargement

Exécutez le code suivant pour télécharger le programme. Qiskit Serverless compresse le contenu de working_dir (dans ce cas, source_files) en un fichier tar, qui est ensuite téléchargé puis supprimé. Ce paramètre entrypoint indique le fichier exécutable principal du programme à lancer pour « 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)

Vérifier le téléchargement

Pour vérifier si le téléchargement s'est bien déroulé, utilisez 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"
)

Output:

QiskitFunction(transpile_remote_serverless)

Etapes suivantes