Code zu Qiskit Serverless portieren

tipp

Qiskit Serverless wird gerade erweitert, und seine Funktionen entwickeln sich schnell weiter. Während dieser Entwicklungsphase findest du Release Notes und die aktuellste Dokumentation auf der Qiskit Serverless GitHub-Seite.

Das folgende Beispiel zeigt, wie du bestehenden Code portierst, um Qiskit Serverless zu nutzen.

hinweis

Der folgende Code setzt voraus, dass du deine Zugangsdaten gespeichert hast. Falls nicht, folge den Anweisungen unter IBM Cloud-Konto einrichten, um dich mit deinem API-Schlüssel zu authentifizieren.

Das Experiment aktualisieren

hinweis

Erstelle in der Serverless-Version den Runtime-Service mit get_runtime_service() (aus qiskit_serverless) anstelle von QiskitRuntimeService(), sodass die IBM Quantum® Compute Service-Jobs und -Sessions, die er startet, dem übergeordneten Qiskit Serverless-Job zugeordnet werden. Siehe Dein erstes Qiskit Serverless-Programm schreiben für Details.

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

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

# Aufgabe auf Worker verteilen
@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)

Ausgabe

'transpile_remote_serverless'

Remote in Qiskit Serverless ausführen

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

Ausgabe

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

Nächste Schritte

Empfehlungen

• Lies einen Fachartikel, in dem Forscher Qiskit Serverless und quantenzentriertes Supercomputing nutzten, um Quantenchemie zu erforschen.