Porter du code vers Qiskit Serverless

conseil

Qiskit Serverless fait l'objet d'une mise à niveau, et ses fonctionnalités évoluent rapidement. Pendant cette phase de développement, les notes de version et la documentation la plus récente sont disponibles sur la page GitHub de Qiskit Serverless.

L'exemple suivant montre comment porter du code existant pour tirer parti de Qiskit Serverless.

remarque

Le code suivant suppose que tu as sauvegardé tes identifiants. Si ce n'est pas le cas, suis les instructions de la page Configurer ton compte IBM Cloud pour t'authentifier avec ta clé API.

Mettre à jour l'expérience

remarque

Dans la version Serverless, crée le service d'exécution avec get_runtime_service() (depuis qiskit_serverless) au lieu de QiskitRuntimeService(), afin que les jobs et sessions du service de calcul IBM Quantum® qu'il lance soient suivis par rapport au job Qiskit Serverless parent. Consulte Écrire ton premier programme Qiskit Serverless pour plus de détails.

Local Experiment

from qiskit.transpiler import generate_preset_pass_manager
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit.circuit.random import random_circuit

qc_random = [(random_circuit(20, 20, measure=True)) for _ in range(30)]
optimization_level = 3

service = QiskitRuntimeService(channel="ibm_quantum_platform")
backend = service.get_backend(backend_name)

pass_manager = generate_preset_pass_manager(
    optimization_level=optimization_level, backend=backend
)

# @distribute_task(target={"cpu": 1})
def transpile_parallel(circuit, pass_manager):
    """Distributed transpilation for an abstract circuit into an ISA circuit for a given backend."""

    isa_circuit = pass_manager.run(circuit)

    return isa_circuit

transpiled_circuits = [
    transpile_parallel(circuit, pass_manager)
    for circuit in circuits
]

print(transpiled_circuits)

Serverless

# transpile_remote.py

from qiskit.transpiler import generate_preset_pass_manager
from qiskit_serverless import get_arguments, save_result, distribute_task, get, get_runtime_service

# Obtenir les arguments du programme
arguments = get_arguments()
circuits = arguments.get("circuits")
backend_name = arguments.get("backend_name")
optimization_level = arguments.get("optimization_level")
pass_manager = generate_preset_pass_manager(
optimization_level=optimization_level, backend=backend_name
)

# Répartir la tâche entre les workers
@distribute_task(target={"cpu": 1})
def transpile_parallel(circuit, pass_manager):
"""Distributed transpilation for an abstract circuit into an ISA circuit for a given backend."""

isa_circuit = pass_manager.run(circuit)

return isa_circuit

try:
# Get backend
service = get_runtime_service()
backend = service.get_backend(backend_name)

# run distributed tasks as async function
# we get task references as a return type
sample_task_references = [
    transpile_parallel(circuit, pass_manager)
    for circuit in circuits
]

# now we need to collect results from task references
results = get(sample_task_references)

# Return results
save_result({
    "transpiled_circuits": results
})

except Exception as e:
# Exception handling
import traceback
print(traceback.format_exc())

Upload to Qiskit Serverless

Follow the instructions on the Introduction to Qiskit Functions page to authenticate with your API key.

from qiskit_ibm_catalog import QiskitServerless, QiskitFunction

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

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

serverless.upload(transpile_remote_demo)

Sortie

'transpile_remote_serverless'

Exécuter à distance dans Qiskit Serverless

from qiskit.circuit.random import random_circuit
from qiskit_ibm_runtime import QiskitRuntimeService

# Setup inputs
qc_random = [(random_circuit(20, 20, measure=True)) for _ in range(30)]
backend = "ibm_brisbane"
optimization_level = 3

# Running program
transpile_remote_serverless = serverless.load('transpile_remote_serverless')
job = transpile_remote_serverless.run(
    circuits=qc_random,
    backend=backend,
    optimization_level=optimization_level
)

job.job_id

Sortie

'727e921d-512d-4b7d-af97-fe29e93ce7ea'

Prochaines étapes

Recommandations

• Lis un article dans lequel des chercheurs ont utilisé Qiskit Serverless et le calcul intensif centré sur le quantique pour explorer la chimie quantique.